Source Code for Module xformslib.library

    1  #!/usr/bin/env python 
    2  # -*- coding: iso8859-1 -*- 
    3   
    4  """ 
    5      xforms-python 
    6      Python wrapper for XForms (X11) GUI C toolkit library using ctypes 
    7   
    8      Copyright (C) 2009  Luca Lazzaroni "LukenShiro"  <lukenshiro@ngi.it> 
    9   
   10      This program is free software: you can redistribute it and/or modify 
   11      it under the terms of the GNU Lesser General Public License as 
   12      published by the Free Software Foundation, version 2.1 of the License. 
   13   
   14      This program is distributed in the hope that it will be useful, 
   15      but WITHOUT ANY WARRANTY; without even the implied warranty of 
   16      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
   17      GNU Lesser General Public License for more details. 
   18   
   19      You should have received a copy of the GNU LGPL along with this 
   20      program. If not, see <http://www.gnu.org/licenses/>. 
   21   
   22      See CREDITS file to read acknowledgements and thanks to XForms, 
   23      ctypes and other developers. 
   24  """ 
   25   
   26  # originally generated by 'h2xml+gccxml' and 'xml2py' 
   27  # then heavily reordered and reworked 
   28   
   29  # ############################################# # 
   30  # Interface to XForms shared object libraries   # 
   31  # ############################################# # 
   32   
   33  import ctypes as cty 
   34  import ctypes.util as ctyutil 
   35  import sys 
   36  import warnings 
   37  from xfdata import *       # data types and constants from XForms 
   38   
   39   
   40  # xforms-python version 
   41  __mainversion__ = "0.3.1"               # real version 
   42  __vers_against_xforms__ = "1.0.93pre2"   # xforms version to be built against 
   43  __version__ = __mainversion__+"_"+__vers_against_xforms__ 
   44   
   45   
   46  header_filename = "/usr/include/forms.h" 
   47   
   48   
   49 -def get_xforms_version(): 
   50      """ Return version string of installed XForms library/header 
   51      """ 
   52   
   53      complete_xf_version = "" 
   54      try: 
   55          formsh = open(header_filename, "r") 
   56      except IOError: 
   57          raise XFormsLoadError("XForms library toolkit header is not " \ 
   58                                " installed properly") 
   59      else: 
   60          try: 
   61              # a reasonable size to catch version values 
   62              fconten = formsh.read(2500) 
   63          except IOError: 
   64              raise XFormsLoadError("XForms library toolkit header is not " \ 
   65                                    "installed properly") 
   66          else: 
   67              formsh.close() 
   68              listconten = fconten.split("\n") 
   69              for singline in listconten: 
   70                  idx_ver = singline.find("FL_VERSION") 
   71                  if idx_ver != -1: 
   72                      strg_ver1 = singline[idx_ver:len(singline)] 
   73                      strg_ver = strg_ver1.replace("FL_VERSION", "").strip(" ") 
   74                      break 
   75              for singline in listconten: 
   76                  idx_rev = singline.find("FL_REVISION") 
   77                  if idx_rev != -1: 
   78                      strg_rev1 = singline[idx_rev:len(singline)] 
   79                      strg_rev = strg_rev1.replace("FL_REVISION", "").strip(" ") 
   80                      break 
   81              for singline in listconten: 
   82                  idx_fix = singline.find("FL_FIXLEVEL") 
   83                  if idx_fix != -1: 
   84                      strg_fix1 = singline[idx_fix:len(singline)] 
   85                      strg_fix = strg_fix1.replace("FL_FIXLEVEL", \ 
   86                                                   "").strip(" ").strip('"') 
   87                      break 
   88              complete_xf_version = strg_ver+"."+strg_rev+"."+strg_fix 
   89   
   90      return complete_xf_version 
   91   
   92   
   93 -def verify_version_compatibility(): 
   94      """ verify compatibility between xforms-python version and XForms version 
   95      """ 
   96   
   97      xforms_vers = get_xforms_version() 
   98      if __vers_against_xforms__ != xforms_vers:      # no match 
   99          warningmsg = "xforms-python is implemented against XForms version " \ 
  100                      " %s and does not match XForms installed version " \ 
  101                      "(%s). Some compatibility problems may arise if XForms" \ 
  102                      " public interface has been modified." % \ 
  103                      (__vers_against_xforms__, xforms_vers) 
  104          warnings.warn(warningmsg, UserWarning) 
  105   
  106   
  107 -class XFormsLoadError(OSError): 
  108      """ Error in loading shared object library """ 
  109   
  110      pass 
  111   
  112   
  113 -class XFormsTypeError(TypeError): 
  114      """ Generic error for type mismatch """ 
  115   
  116      pass 
  117   
  118   
  119 -def warn_deprecated_function(altfunc=""): 
  120      """ Warns the user when a function is deprecated and should not be used 
  121          anymore. If a param is provided it may advide the user about an 
  122          alternative function. 
  123      """ 
  124   
  125      funcname = sys._getframe(1).f_code.co_name 
  126      if altfunc: 
  127          newaltfunc = "Use %s instead." % altfunc 
  128      else: 
  129          newaltfunc = "" 
  130      warningmsg = "Function %s is deprecated and might be removed in future" \ 
  131                    " releases. %s" % (funcname, newaltfunc) 
  132      warnings.warn(warningmsg, DeprecationWarning, 3) 
  133   
  134   
  135 -def func_do_nothing_placeholder(cfunction): 
  136      """ Print a warning if called function doesn't exist 
  137      """ 
  138   
  139      warningmsg = "C function %s does NOT exist, hence its call is ignored," \ 
  140                   " hence it is not wrappable and callable in python, as " \ 
  141                   "well. Maybe removed or disabled?" % cfunction 
  142      warnings.warn(warningmsg, UserWarning) 
  143      return None 
  144   
  145   
  146  # placeholders to keep reference to c functions 
  147  # keeps global to avoid garbage collector's' unpredictable behaviour 
  148  _cfunc_refs = [] 
  149  # just in case, maintains elements used as parameters, too 
  150  _elem_refs = [] 
  151   
  152   
  153 -def keep_cfunc_refs(*cfunclist): 
  154      """ Adds a reference for _cfunc_refs list of values 
  155      """ 
  156   
  157      for singvalue in cfunclist: 
  158          _cfunc_refs.append(singvalue) 
  159   
  160   
  161 -def keep_elem_refs(*elemlist): 
  162      """ Adds a reference for _elem_refs list of values 
  163      """ 
  164   
  165      for singvalue in elemlist: 
  166          _elem_refs.append(singvalue) 
  167   
  168   
  169  loaded_xlibraries = {'libforms' : None, 'libflimage' : None, \ 
  170                      'libformsgl' : None, 'libx11' : None} 
  171   
  172   
  173 -def load_so_libforms(): 
  174      """ Load libforms.so else raise an error -> library instance 
  175      """ 
  176   
  177      if loaded_xlibraries['libforms'] is None: 
  178          libfbase = ctyutil.find_library("forms") 
  179          if not libfbase:    # not installed 
  180              raise XFormsLoadError("XForms library toolkit is not installed" \ 
  181                                    " properly") 
  182          else: 
  183              loaded_xlibraries['libforms'] = cty.cdll.LoadLibrary(libfbase) 
  184      return loaded_xlibraries['libforms'] 
  185   
  186   
  187 -def load_so_libflimage(): 
  188      """ Load libflimage.so else raise an error -> library instance 
  189      """ 
  190   
  191      if loaded_xlibraries['libflimage'] is None: 
  192          libfimg = ctyutil.find_library("flimage") 
  193          if not libfimg:    # not installed 
  194              raise XFormsLoadError("XForms library toolkit is not installed" \ 
  195                                    " properly") 
  196          else: 
  197              loaded_xlibraries['libflimage'] = cty.cdll.LoadLibrary(libfimg) 
  198      return loaded_xlibraries['libflimage'] 
  199   
  200   
  201 -def load_so_libformsgl(): 
  202      """ Load libformsGL.so else raise an error -> library instance 
  203      """ 
  204   
  205      if loaded_xlibraries['libformsgl'] is None: 
  206          libfgl = ctyutil.find_library("formsGL") 
  207          if not libfgl:    # not installed 
  208              raise XFormsLoadError("XForms library toolkit is not installed" \ 
  209                                    " properly, with OpenGL support") 
  210          else: 
  211              loaded_xlibraries['libformsgl'] = cty.cdll.LoadLibrary(libfgl) 
  212      return loaded_xlibraries['libformsgl'] 
  213   
  214   
  215 -def load_so_libx11(): 
  216      """ Load libX11.so.6 else raise an error -> library instance 
  217      """ 
  218   
  219      if loaded_xlibraries['libx11'] is None: 
  220          libx11 = ctyutil.find_library("X11") 
  221          if not libx11:    # not installed 
  222              raise XFormsLoadError("X11 libraries are not installed" \ 
  223                                    " properly") 
  224          else: 
  225              loaded_xlibraries['libx11'] = cty.cdll.LoadLibrary(libx11) 
  226      return loaded_xlibraries['libx11'] 
  227   
  228   
  229 -def cfuncproto(library, cfuncname, retval, arglist, doc=""): 
  230      """ Prototype for C function to be wrapped in python 
  231      """ 
  232   
  233      loadedfunc = None 
  234      try: 
  235          loadedfunc = getattr(library, cfuncname) 
  236      except AttributeError: 
  237          # function doesn't exist 
  238          loadedfunc = func_do_nothing_placeholder(cfuncname) 
  239      else: 
  240          loadedfunc.restype = retval 
  241          loadedfunc.argtypes = arglist 
  242          loadedfunc.__doc__ = doc 
  243   
  244      return loadedfunc 
  245   
  246   
  247  # functions to convert a parameter into a python type then into the 
  248  # equivalent ctypes type 
  249   
  250 -def convert_to_string(paramname): 
  251      """ Converts paramname to python str and to ctypes c_char_p """ 
  252   
  253      try: 
  254          retv0 = str(paramname) 
  255      except ValueError: 
  256          raise XFormsTypeError("Parameter cannot be converted into" \ 
  257                                "'str'/'c_char_p'") 
  258      retv = cty.c_char_p(retv0) 
  259      #print "string", paramname, retv0, retv 
  260      return retv 
  261   
  262   
  263 -def convert_to_int(paramname): 
  264      """ Converts paramname to python int and to ctypes c_int """ 
  265   
  266      if not isinstance(paramname, cty.c_int): 
  267          try: 
  268              retv0 = int(paramname) 
  269          except ValueError: 
  270              raise XFormsTypeError("Parameter cannot be converted into" \ 
  271                                    " 'int'/'c_int'") 
  272          retv = cty.c_int(retv0) 
  273          #print "int", paramname, retv0, retv 
  274          return retv 
  275      else: 
  276          return paramname 
  277   
  278  convert_to_FL_Coord = convert_to_int 
  279   
  280   
  281 -def convert_to_uint(paramname): 
  282      """ Converts paramname to python int and to ctypes c_uint """ 
  283   
  284      if not isinstance(paramname, cty.c_int): 
  285          try: 
  286              retv0 = int(paramname) 
  287          except ValueError: 
  288              raise XFormsTypeError("Parameter cannot be converted into" \ 
  289                                    " 'int'/'c_uint'") 
  290          else: 
  291              retv = cty.c_uint(retv0) 
  292              #print "uint", paramname, retv0, retv 
  293              return retv 
  294      else: 
  295          return paramname 
  296   
  297   
  298 -def convert_to_long(paramname): 
  299      """ Converts paramname to python long and to ctypes c_long """ 
  300   
  301      if not isinstance(paramname, cty.c_long): 
  302          try: 
  303              retv0 = long(paramname) 
  304          except ValueError: 
  305              raise XFormsTypeError("Parameter cannot be converted into" \ 
  306                                    " 'long'/'c_long'") 
  307          else: 
  308              retv = cty.c_long(retv0) 
  309              #print "long", paramname, retv0, retv 
  310              return retv 
  311      else: 
  312          return paramname 
  313   
  314   
  315 -def convert_to_ulong(paramname): 
  316      """ Converts paramname to python long and to ctypes c_ulong """ 
  317   
  318      if not isinstance(paramname, cty.c_ulong): 
  319          try: 
  320              retv0 = long(paramname) 
  321          except ValueError: 
  322              raise XFormsTypeError("Parameter cannot be converted into" \ 
  323                                " 'long'/'c_ulong'") 
  324          else: 
  325              retv = cty.c_ulong(retv0) 
  326              #print "ulong", paramname, retv0, retv 
  327              return retv 
  328      else: 
  329          return paramname 
  330   
  331   
  332  convert_to_FL_COLOR = convert_to_ulong 
  333  convert_to_Window = convert_to_ulong 
  334  convert_to_Pixmap = convert_to_ulong 
  335   
  336   
  337 -def convert_to_double(paramname): 
  338      """ Converts paramname to python float and to ctypes c_double """ 
  339   
  340      if not isinstance(paramname, cty.c_double): 
  341          try: 
  342              retv0 = float(paramname) 
  343          except ValueError: 
  344              raise XFormsTypeError("Parameter cannot be converted into" \ 
  345                                    " 'float'/'c_double'") 
  346          else: 
  347              retv = cty.c_double(retv0) 
  348              #print "double", paramname, retv0, retv 
  349              return retv 
  350      else: 
  351          return paramname 
  352   
  353   
  354 -def convert_to_float(paramname): 
  355      """ Converts paramname to python float and to ctypes c_float """ 
  356   
  357      if not isinstance(paramname, cty.c_float): 
  358          try: 
  359              retv0 = float(paramname) 
  360          except ValueError: 
  361              raise XFormsTypeError("Parameter cannot be converted into" \ 
  362                                    " 'float'/'c_float'") 
  363          else: 
  364              retv = cty.c_float(retv0) 
  365              #print "float", paramname, retv0, retv 
  366              return retv 
  367      else: 
  368          return paramname 
  369   
  370   
  371 -def convert_to_ubyte(paramname): 
  372      """ Converts paramname to ctypes c_ubyte """ 
  373   
  374      retv = cty.c_ubyte(paramname) 
  375      return retv 
  376   
  377   
  378 -def make_int_and_pointer(): 
  379      """ Makes a ctypes c_int and its pointer, and returns both """ 
  380   
  381      baseval = cty.c_int() 
  382      ptrbaseval = cty.byref(baseval) 
  383      return baseval, ptrbaseval 
  384   
  385  make_FL_Coord_and_pointer = make_int_and_pointer 
  386   
  387   
  388 -def make_uint_and_pointer(): 
  389      """ Makes a ctypes c_uint and its pointer, and returns both """ 
  390   
  391      baseval = cty.c_uint() 
  392      ptrbaseval = cty.byref(baseval) 
  393      return baseval, ptrbaseval 
  394   
  395   
  396 -def make_long_and_pointer(): 
  397      """ Makes a ctypes c_long and its pointer, and returns both """ 
  398   
  399      baseval = cty.c_long() 
  400      ptrbaseval = cty.byref(baseval) 
  401      return baseval, ptrbaseval 
  402   
  403   
  404 -def make_ulong_and_pointer(): 
  405      """ Makes a ctypes c_ulong and its pointer, and returns both """ 
  406   
  407      baseval = cty.c_ulong() 
  408      ptrbaseval = cty.byref(baseval) 
  409      return baseval, ptrbaseval 
  410   
  411  make_Pixmap_and_pointer = make_ulong_and_pointer 
  412  make_FL_COLOR_and_pointer = make_ulong_and_pointer 
  413   
  414   
  415 -def make_float_and_pointer(): 
  416      """ Makes a ctypes c_float and its pointer, and returns both """ 
  417   
  418      baseval = cty.c_float() 
  419      ptrbaseval = cty.byref(baseval) 
  420      return baseval, ptrbaseval 
  421   
  422   
  423 -def make_double_and_pointer(): 
  424      """ Makes a ctypes c_double and its pointer, and returns both """ 
  425   
  426      baseval = cty.c_double() 
  427      ptrbaseval = cty.byref(baseval) 
  428      return baseval, ptrbaseval 
  429   
  430   
  431 -def check_admitted_listvalues(paramname, *valueslist): 
  432      """ Check if paramname value is valid in accordance to a list 
  433          of admissible values. 
  434      """ 
  435   
  436      if isinstance(valueslist, list): 
  437          if paramname not in valueslist: 
  438              raise XFormsTypeError("Parameter value must be included in " \ 
  439                                    "list %s." % valueslist) 
  440   
  441   
  442  # exported variables 
  443  FL_EVENT = (cty.POINTER(FL_OBJECT)).in_dll(load_so_libforms(), 'FL_EVENT') 
  444  fl_current_form = (cty.POINTER(FL_FORM)).in_dll(load_so_libforms(), \ 
  445                    'fl_current_form') 
  446  fl_display = (cty.POINTER(Display)).in_dll(load_so_libforms(), 'fl_display') 
  447  fl_screen = (cty.c_int).in_dll(load_so_libforms(), 'fl_screen') 
  448  # root window 
  449  fl_root = (Window).in_dll(load_so_libforms(), 'fl_root') 
  450  # virtual root window 
  451  fl_vroot = (Window).in_dll(load_so_libforms(), 'fl_vroot') 
  452  # screen dimension in pixels 
  453  fl_scrh = (cty.c_int).in_dll(load_so_libforms(), 'fl_scrh') 
  454  fl_scrw = (cty.c_int).in_dll(load_so_libforms(), 'fl_scrw') 
  455  fl_vmode = (cty.c_int).in_dll(load_so_libforms(), 'fl_vmode') 
  456  fl_state = (cty.POINTER(FL_State)).in_dll(load_so_libforms(), 'fl_state') 
  457  fl_ul_magic_char = (STRING).in_dll(load_so_libforms(), 'fl_state') 
  458   
  459   
  460  ######################################## 
  461  # forms.h (Basic.h) 
  462  #  Basic definitions and limits. 
  463  #  Window system independent prototypes 
  464  #  Modify with care 
  465  ######################################## 
  466   
  467   
  468 -def FL_IS_UPBOX(t): 
  469      if (t == FL_UP_BOX) or \ 
  470          (t == FL_OVAL3D_UPBOX) or \ 
  471          (t == FL_ROUNDED3D_UPBOX): 
  472          return True 
  473      else: 
  474          return False 
  475   
  476   
  477 -def FL_IS_DOWNBOX(t): 
  478      if (t == FL_DOWN_BOX) or \ 
  479          (t == FL_OVAL3D_DOWNBOX) or \ 
  480          (t == FL_ROUNDED3D_DOWNBOX): 
  481          return True 
  482      else: 
  483          return False 
  484   
  485   
  486 -def FL_TO_DOWNBOX(t): 
  487      if t == FL_UP_BOX: 
  488          t1 = FL_DOWN_BOX 
  489      elif t == FL_ROUNDED3D_UPBOX: 
  490          t1 = FL_ROUNDED3D_DOWNBOX 
  491      elif t == FL_OVAL3D_UPBOX: 
  492          t1 = FL_OVAL3D_DOWNBOX 
  493      else: 
  494          t1 = t 
  495      return t1 
  496   
  497   
  498 -def special_style(a): 
  499      if (a >= FL_SHADOW_STYLE) and \ 
  500       (a <= (FL_EMBOSSED_STYLE + FL_MAXFONTS)): 
  501          return True 
  502      else: 
  503          return False 
  504   
  505   
  506   
  507   
  508  # Macro for getting at the object handlers return value 
  509   
  510 -def fl_object_returned(pObject): 
  511      return pObject.contents.returned 
  512   
  513   
  514  # IO other than XEvent Q 
  515   
  516  FL_IO_CALLBACK = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 
  517   
  518 -def fl_add_io_callback(fd, mask, py_IoCallback, data): 
  519      """ 
  520          fl_add_io_callback(fd, mask, py_IoCallback, data) 
  521   
  522          Registers an input callback function when input is available from fd. 
  523   
  524          @param fd : a valid file descriptor in a *nix system 
  525          @param mask : under what circumstance the input callback should be 
  526             invoked (i.e. FL_READ, FL_WRITE or FL_EXCEPT) 
  527          @param py_IoCallback : python function to be invoked under mask 
  528             condition, fn(num, ptr_void) 
  529          @param data : argument to be passed to function 
  530      """ 
  531   
  532      _fl_add_io_callback = cfuncproto( 
  533              load_so_libforms(), "fl_add_io_callback", \ 
  534              None, [cty.c_int, cty.c_uint, FL_IO_CALLBACK, cty.c_void_p], \ 
  535              """void fl_add_io_callback(int fd, unsigned int mask, 
  536                 FL_IO_CALLBACK callback, void * data) 
  537              """) 
  538      ifd = convert_to_int(fd) 
  539      uimask = convert_to_uint(mask) 
  540      c_IoCallback = FL_IO_CALLBACK(py_IoCallback) 
  541      pdata = cty.cast(data, cty.c_void_p) 
  542      keep_cfunc_refs(c_IoCallback, py_IoCallback) 
  543      keep_elem_refs(fd, ifd, mask, uimask, data, pdata) 
  544      _fl_add_io_callback(ifd, uimask, c_IoCallback, pdata) 
  545   
  546   
  547 -def fl_remove_io_callback(fd, mask, py_IoCallback): 
  548      """ 
  549          fl_remove_io_callback(fd, mask, py_IoCallback) 
  550   
  551          Removes the registered callback function when input is available 
  552          from fd. 
  553   
  554          @param fd : a valid file descriptor in a unix system 
  555          @param mask : under what circumstance the input callback should be 
  556             removed (i.e. xfc.FL_READ, xfc.FL_WRITE, xfc.FL_EXCEPT) 
  557          @param py_IoCallback : python function to be removed under mask 
  558             condition, fn(num, ptr_void) 
  559      """ 
  560   
  561      _fl_remove_io_callback = cfuncproto( 
  562              load_so_libforms(), "fl_remove_io_callback", \ 
  563              None, [cty.c_int, cty.c_uint, FL_IO_CALLBACK], \ 
  564              """void fl_remove_io_callback(int fd, unsigned int mask, 
  565                 FL_IO_CALLBACK cb) 
  566              """) 
  567      check_admitted_listvalues(mask, ASYNCIO_list) 
  568      ifd = convert_to_int(fd) 
  569      uimask = convert_to_uint(mask) 
  570      c_IoCallback = FL_IO_CALLBACK(py_IoCallback) 
  571      keep_cfunc_refs(c_IoCallback, py_IoCallback) 
  572      keep_elem_refs(fd, ifd, mask, uimask) 
  573      _fl_remove_io_callback(ifd, uimask, c_IoCallback) 
  574   
  575   
  576  # signals 
  577   
  578  FL_SIGNAL_HANDLER = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 
  579   
  580 -def fl_add_signal_callback(sglnum, py_SignalHandler, data): 
  581      """ 
  582          fl_add_signal_callback(sglnum, py_SignalHandler, data) 
  583   
  584          Handles the receipt of a signal by registering a callback function 
  585          that gets called when a signal is caught (only 1 function per signal) 
  586   
  587          @param sglnum : signal number (e.g. SIGALRM, SIGINT, etc.) 
  588          @param py_SignalHandler : python function to be invoked after 
  589             catching the signal, fn(num, ptr_void) 
  590          @param data : argument to be passed to function 
  591      """ 
  592   
  593      _fl_add_signal_callback = cfuncproto( 
  594              load_so_libforms(), "fl_add_signal_callback", \ 
  595              None, [cty.c_int, FL_SIGNAL_HANDLER, cty.c_void_p], \ 
  596              """void fl_add_signal_callback(int s, FL_SIGNAL_HANDLER cb, 
  597                 void * data) 
  598              """) 
  599      isglnum = convert_to_int(sglnum) 
  600      c_SignalHandler = FL_SIGNAL_HANDLER(py_SignalHandler) 
  601      pdata = cty.cast(data, cty.c_void_p) 
  602      keep_cfunc_refs(c_SignalHandler, py_SignalHandler) 
  603      keep_elem_refs(sglnum, isglnum, data, pdata) 
  604      _fl_add_signal_callback(isglnum, c_SignalHandler, pdata) 
  605   
  606   
  607 -def fl_remove_signal_callback(sglnum): 
  608      """ 
  609          fl_remove_signal_callback(sglnum) 
  610   
  611          Removes a previously registered callback function related to a signal. 
  612   
  613          @param sglnum : signal number (e.g. SIGALRM, SIGINT, etc.) 
  614      """ 
  615   
  616      _fl_remove_signal_callback = cfuncproto( 
  617              load_so_libforms(), "fl_remove_signal_callback", \ 
  618              None, [cty.c_int], \ 
  619              """void fl_remove_signal_callback(int s) 
  620              """) 
  621      isglnum = convert_to_int(sglnum) 
  622      keep_elem_refs(sglnum, isglnum) 
  623      _fl_remove_signal_callback(isglnum) 
  624   
  625   
  626 -def fl_signal_caught(sglnum): 
  627      """ 
  628          fl_signal_caught(sglnum) 
  629   
  630          Informs the main loop of the delivery of the signal signum, the signal 
  631          is received by the application program 
  632   
  633          @param sglnum : signal number (e.g. SIGALRM, SIGINT, etc.) 
  634      """ 
  635   
  636      _fl_signal_caught = cfuncproto( 
  637              load_so_libforms(), "fl_signal_caught", \ 
  638              None, [cty.c_int], \ 
  639              """void fl_signal_caught(int s) 
  640              """) 
  641      isglnum = convert_to_int(sglnum) 
  642      keep_elem_refs(sglnum, isglnum) 
  643      _fl_signal_caught(isglnum) 
  644   
  645   
  646 -def fl_app_signal_direct(flag): 
  647      """ 
  648          fl_app_signal_direct(flag) 
  649   
  650          Changes the default behavior of the built-in signal facilities (to 
  651          be called with a true value for flag prior to any use of 
  652          fl_add_signal_callback 
  653   
  654          @param flag : flag (0|1) 
  655      """ 
  656   
  657      _fl_app_signal_direct = cfuncproto( 
  658              load_so_libforms(), "fl_app_signal_direct", \ 
  659              None, [cty.c_int], \ 
  660              """void fl_app_signal_direct(int y) 
  661              """) 
  662      iflag = convert_to_int(flag) 
  663      keep_elem_refs(flag, iflag) 
  664      _fl_app_signal_direct(iflag) 
  665   
  666   
  667  # timeouts 
  668   
  669  FL_TIMEOUT_CALLBACK = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 
  670   
  671 -def fl_add_timeout(msec, py_TimeoutCallback, data): 
  672      """ 
  673          fl_add_timeout(msec, py_TimeoutCallback, data) -> timer ID 
  674   
  675          Adds a timeout callback after a specified elapsed time. 
  676   
  677          @param msec : time elapsed in milliseconds 
  678          @param py_TimeoutCallback : python function to be invoked after time, 
  679             fn(num, ptr_void) 
  680          @param data : argument to be passed to function 
  681      """ 
  682   
  683      _fl_add_timeout = cfuncproto( 
  684              load_so_libforms(), "fl_add_timeout", \ 
  685              cty.c_int, [cty.c_long, FL_TIMEOUT_CALLBACK, cty.c_void_p], \ 
  686              """int fl_add_timeout(long int msec, 
  687                 FL_TIMEOUT_CALLBACK callback, void * data) 
  688              """) 
  689      lmsec = convert_to_long(msec) 
  690      pdata = cty.cast(data, cty.c_void_p) 
  691      c_TimeoutCallback = FL_TIMEOUT_CALLBACK(py_TimeoutCallback) 
  692      keep_cfunc_refs(c_TimeoutCallback, py_TimeoutCallback) 
  693      keep_elem_refs(msec, lmsec, data, pdata) 
  694      retval = _fl_add_timeout(lmsec, c_TimeoutCallback, pdata) 
  695      return retval 
  696   
  697   
  698 -def fl_remove_timeout(idnum): 
  699      """ 
  700          fl_remove_timeout(idnum) 
  701   
  702          Removes a timeout callback function (created with fl_add_timeout). 
  703   
  704          @param idnum : ID timeout number 
  705      """ 
  706   
  707      _fl_remove_timeout = cfuncproto( 
  708              load_so_libforms(), "fl_remove_timeout", \ 
  709              None, [cty.c_int], \ 
  710              """void fl_remove_timeout(int id) 
  711              """) 
  712      iidnum = convert_to_int(idnum) 
  713      keep_elem_refs(idnum, iidnum) 
  714      _fl_remove_timeout(iidnum) 
  715   
  716   
  717  # Basic public routine prototypes 
  718   
  719  #def fl_library_version(ver, rev)       *API change* 
  720 -def fl_library_version(): 
  721      """ 
  722          fl_library_version() -> version_rev ID, ver, rev 
  723   
  724          Returns consolidated version informations. 
  725   
  726          Returns: 
  727          <version_rev> : computed as 1000 * version + revision 
  728          <ver> : version (e.g. 1 in 1.x.yy) 
  729          <rev> : revision (e.g. 0 in x.0.yy) 
  730      """ 
  731   
  732      _fl_library_version = cfuncproto( 
  733              load_so_libforms(), "fl_library_version", \ 
  734              cty.c_int, [cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], \ 
  735              """int fl_library_version(int * ver, int * rev) 
  736              """) 
  737      ver, pver = make_int_and_pointer() 
  738      rev, prev = make_int_and_pointer() 
  739      keep_elem_refs(ver, rev, pver, prev) 
  740      retval = _fl_library_version(pver, prev) 
  741      return retval, ver, rev 
  742   
  743   
  744  # Generic routines that deal with FORMS 
  745   
  746 -def fl_bgn_form(formtype, w, h): 
  747      """ 
  748          fl_bgn_form(formtype, w, h) -> pForm 
  749   
  750          Starts the definition of a form call. 
  751   
  752          @param formtype : type of box that is used as a background 
  753             (e.g. FL_DOWN_BOX, FL_BORDER_BOX, FL_SHADOW_BOX, etc.) 
  754          @param w : width of the new form 
  755          @param h : height of the new form 
  756      """ 
  757   
  758      _fl_bgn_form = cfuncproto( 
  759              load_so_libforms(), "fl_bgn_form", \ 
  760              cty.POINTER(FL_FORM), [cty.c_int, FL_Coord, FL_Coord], \ 
  761              """FL_FORM * fl_bgn_form(int type, FL_Coord w, FL_Coord h) 
  762              """) 
  763      check_admitted_listvalues(formtype, BOXTYPE_list) 
  764      iformtype = convert_to_int(formtype) 
  765      iw = convert_to_FL_Coord(w) 
  766      ih = convert_to_FL_Coord(h) 
  767      keep_elem_refs(formtype, iformtype, w, iw, h, ih) 
  768      retval = _fl_bgn_form(iformtype, iw, ih) 
  769      return retval 
  770   
  771   
  772 -def fl_end_form(): 
  773      """ 
  774          fl_end_form() 
  775   
  776          Ends the definition for a form call, after all required objects 
  777          have been added to a form call. 
  778      """ 
  779   
  780      _fl_end_form = cfuncproto( 
  781              load_so_libforms(), "fl_end_form", \ 
  782              None, [], \ 
  783              """void fl_end_form() 
  784              """) 
  785      _fl_end_form() 
  786   
  787   
  788 -def fl_do_forms(): 
  789      """ 
  790          fl_do_forms() -> pObject 
  791   
  792          Starts the main loop of the program and returns only when the state 
  793          of an object changes that has no callback bound to it. 
  794      """ 
  795   
  796      _fl_do_forms = cfuncproto( 
  797              load_so_libforms(), "fl_do_forms", \ 
  798              cty.POINTER(FL_OBJECT), [], \ 
  799              """FL_OBJECT * fl_do_forms() 
  800              """) 
  801      retval = _fl_do_forms() 
  802      return retval 
  803   
  804   
  805 -def fl_check_forms(): 
  806      """ 
  807          fl_check_forms() -> pObject 
  808   
  809          Returns None immediately unless the state of one of the object 
  810          (without a callback bound to it) changed. 
  811      """ 
  812   
  813      _fl_check_forms = cfuncproto( 
  814              load_so_libforms(), "fl_check_forms", \ 
  815              cty.POINTER(FL_OBJECT), [], \ 
  816              """FL_OBJECT * fl_check_forms() 
  817              """) 
  818      retval = _fl_check_forms() 
  819      return retval 
  820   
  821   
  822 -def fl_do_only_forms(): 
  823      """ 
  824          fl_do_only_forms() -> pObject 
  825   
  826          Starts the main loop of the program and returns only when the state of 
  827          an object changes that has no callback bound to it. It does not 
  828          handle user events generated by application windows opened via 
  829          fl_winopen() or similar routines. 
  830      """ 
  831   
  832      _fl_do_only_forms = cfuncproto( 
  833              load_so_libforms(), "fl_do_only_forms", \ 
  834              cty.POINTER(FL_OBJECT), [], \ 
  835              """FL_OBJECT * fl_do_only_forms() 
  836              """) 
  837      retval = _fl_do_only_forms() 
  838      return retval 
  839   
  840   
  841 -def fl_check_only_forms(): 
  842      """ 
  843          fl_check_only_forms() -> pObject 
  844   
  845          Returns None immediately unless the state of one of the object 
  846          (without a callback bound to it) changed. It does not handle user 
  847          events generated by application windows opened via fl_winopen() or 
  848          similar routines. 
  849      """ 
  850   
  851      _fl_check_only_forms = cfuncproto( 
  852              load_so_libforms(), "fl_check_only_forms", \ 
  853              cty.POINTER(FL_OBJECT), [], \ 
  854              """FL_OBJECT * fl_check_only_forms() 
  855              """) 
  856      retval = _fl_check_only_forms() 
  857      return retval 
  858   
  859   
  860 -def fl_freeze_form(pForm): 
  861      """ 
  862          fl_freeze_form(pForm) 
  863   
  864          It does not temporarily redraw a form while changes are being made, so 
  865          all changes made are instead buffered internally. 
  866   
  867          @param pForm : pointer to form not to be re-drawn temporarly 
  868      """ 
  869   
  870      _fl_freeze_form = cfuncproto( 
  871              load_so_libforms(), "fl_freeze_form", \ 
  872              None, [cty.POINTER(FL_FORM)], \ 
  873              """void fl_freeze_form(FL_FORM * form) 
  874              """) 
  875      keep_elem_refs(pForm) 
  876      _fl_freeze_form(pForm) 
  877   
  878   
  879 -def fl_set_focus_object(pForm, pObject): 
  880      """ 
  881          fl_set_focus_object(pForm, pObject) 
  882   
  883          Sets the input focus in form to object pObject. 
  884   
  885          @param pForm : pointer to form whose object has to be focused 
  886          @param pObject : pointer to object to be focused 
  887      """ 
  888   
  889      _fl_set_focus_object = cfuncproto( 
  890              load_so_libforms(), "fl_set_focus_object", \ 
  891              None, [cty.POINTER(FL_FORM), cty.POINTER(FL_OBJECT)], \ 
  892              """void fl_set_focus_object(FL_FORM * form, FL_OBJECT * obj) 
  893              """) 
  894      keep_elem_refs(pForm, pObject) 
  895      _fl_set_focus_object(pForm, pObject) 
  896   
  897   
  898  fl_set_object_focus = fl_set_focus_object 
  899   
  900   
  901 -def fl_get_focus_object(pForm): 
  902      """ 
  903          fl_get_focus_object(pForm) -> pObject 
  904   
  905          Obtains the object that has the focus on a form. 
  906   
  907          @param pForm : pointer to form that has a focused object 
  908      """ 
  909   
  910      _fl_get_focus_object = cfuncproto( 
  911              load_so_libforms(), "fl_get_focus_object", \ 
  912              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_FORM)], \ 
  913              """FL_OBJECT * fl_get_focus_object(FL_FORM * form) 
  914              """) 
  915      keep_elem_refs(pForm) 
  916      retval = _fl_get_focus_object(pForm) 
  917      return retval 
  918   
  919   
  920 -def fl_reset_focus_object(pObject): 
  921      """ 
  922          fl_reset_focus_object(pObject) 
  923   
  924          Override the FL_UNFOCUS event. 
  925   
  926          @param pObject : pointer to object towards applying event 
  927      """ 
  928   
  929      _fl_reset_focus_object = cfuncproto( 
  930              load_so_libforms(), "fl_reset_focus_object", \ 
  931              None, [cty.POINTER(FL_OBJECT)], \ 
  932              """void fl_reset_focus_object(FL_OBJECT * ob) 
  933              """) 
  934      keep_elem_refs(pObject) 
  935      _fl_reset_focus_object(pObject) 
  936   
  937   
  938  #already defined in xfdata 
  939  #FL_FORM_ATCLOSE = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_FORM), cty.c_void_p) 
  940   
  941 -def fl_set_form_atclose(pForm, py_FormAtclose, data): 
  942      """ 
  943          fl_set_form_atclose(pForm, py_FormAtclose, data) -> FormAtclose func. 
  944   
  945          Calls a callback function before closing the form. 
  946   
  947          @param pForm : pointer to form that receives the message 
  948          @param py_FormAtclose : python callback function to be called, 
  949             fn(pForm, ptr_void) -> num 
  950          @param data : argument to be passed to function 
  951      """ 
  952   
  953      _fl_set_form_atclose = cfuncproto( 
  954              load_so_libforms(), "fl_set_form_atclose", \ 
  955              FL_FORM_ATCLOSE, [cty.POINTER(FL_FORM), FL_FORM_ATCLOSE, 
  956              cty.c_void_p], \ 
  957              """FL_FORM_ATCLOSE fl_set_form_atclose(FL_FORM * form, 
  958                 FL_FORM_ATCLOSE fmclose, void * data) 
  959              """) 
  960      c_FormAtclose = FL_FORM_ATCLOSE(py_FormAtclose) 
  961      pdata = cty.cast(data, cty.c_void_p) 
  962      keep_cfunc_refs(c_FormAtclose, py_FormAtclose) 
  963      keep_elem_refs(pForm, data, pdata) 
  964      retval = _fl_set_form_atclose(pForm, c_FormAtclose, pdata) 
  965      return retval 
  966   
  967   
  968 -def fl_set_atclose(py_FormAtclose, data): 
  969      """ 
  970          fl_set_atclose(py_FormAtclose, data) -> FormAtclose func. 
  971   
  972          Calls a callback function before terminating the application. 
  973   
  974          @param py_FormAtclose : callback function to be called, fn(pForm, 
  975             ptr_void) -> num 
  976          @param data : argument to be passed to function 
  977      """ 
  978   
  979      _fl_set_atclose = cfuncproto( 
  980              load_so_libforms(), "fl_set_atclose", \ 
  981              FL_FORM_ATCLOSE, [FL_FORM_ATCLOSE, cty.c_void_p], \ 
  982              """FL_FORM_ATCLOSE fl_set_atclose(FL_FORM_ATCLOSE fmclose, 
  983                 void * data) 
  984              """) 
  985      c_FormAtclose = FL_FORM_ATCLOSE(py_FormAtclose) 
  986      pdata = cty.cast(data, cty.c_void_p) 
  987      keep_cfunc_refs(c_FormAtclose, py_FormAtclose) 
  988      keep_elem_refs(data, pdata) 
  989      retval = _fl_set_atclose(c_FormAtclose, pdata) 
  990      return retval 
  991   
  992   
  993  #already defined in xfdata 
  994  #FL_FORM_ATACTIVATE = cty.CFUNCTYPE(None, cty.POINTER(FL_FORM), cty.c_void_p) 
  995   
  996 -def fl_set_form_atactivate(pForm, py_FormAtactivate, data): 
  997      """ 
  998          fl_set_form_atactivate(pForm, py_FormAtactivate, data) -> FormAtactivate func. 
  999   
 1000          Register a callback that is called when activation status of a forms 
 1001          is enabled, 
 1002   
 1003          @param pForm : activated form 
 1004          @param py_FormAtactivate : python callback function called, fn(pForm, 
 1005             ptr_void) 
 1006          @param data : argument to be passed to function 
 1007      """ 
 1008   
 1009      _fl_set_form_atactivate = cfuncproto( 
 1010              load_so_libforms(), "fl_set_form_atactivate", \ 
 1011              FL_FORM_ATACTIVATE, [cty.POINTER(FL_FORM), FL_FORM_ATACTIVATE, 
 1012              cty.c_void_p], \ 
 1013              """FL_FORM_ATACTIVATE fl_set_form_atactivate(FL_FORM * form, 
 1014                 FL_FORM_ATACTIVATE cb, void * data) 
 1015              """) 
 1016      c_FormAtactivate = FL_FORM_ATACTIVATE(py_FormAtactivate) 
 1017      pdata = cty.cast(data, cty.c_void_p) 
 1018      keep_cfunc_refs(c_FormAtactivate, py_FormAtactivate) 
 1019      keep_elem_refs(pForm, data, pdata) 
 1020      retval = _fl_set_form_atactivate(pForm, c_FormAtactivate, pdata) 
 1021      return retval 
 1022   
 1023   
 1024  #already defined in xfdata 
 1025  #FL_FORM_ATDEACTIVATE = cty.CFUNCTYPE(None, cty.POINTER(FL_FORM), cty.c_void_p) 
 1026   
 1027 -def fl_set_form_atdeactivate(pForm, py_FormAtdeactivate, data): 
 1028      """ 
 1029          fl_set_form_atdeactivate(pForm, py_FormAtdeactivate, data) -> FormAtdeactivate func. 
 1030   
 1031          Register a callback that is called when activation status of a forms 
 1032          is disabled. 
 1033   
 1034          @param pForm : pointer to de-activated form 
 1035          @param py_FormAtdeactivate : python callback function called, 
 1036             fn(pForm, ptr_void) 
 1037          @param data : argument to be passed to function 
 1038      """ 
 1039   
 1040      _fl_set_form_atdeactivate = cfuncproto( 
 1041              load_so_libforms(), "fl_set_form_atdeactivate", \ 
 1042              FL_FORM_ATDEACTIVATE, [cty.POINTER(FL_FORM), 
 1043              FL_FORM_ATDEACTIVATE, cty.c_void_p], \ 
 1044              """FL_FORM_ATDEACTIVATE fl_set_form_atdeactivate(FL_FORM * form, 
 1045                 FL_FORM_ATDEACTIVATE cb, void * data) 
 1046              """) 
 1047      c_FormAtdeactivate = FL_FORM_ATDEACTIVATE(py_FormAtdeactivate) 
 1048      pdata = cty.cast(data, cty.c_void_p) 
 1049      keep_cfunc_refs(c_FormAtdeactivate, py_FormAtdeactivate) 
 1050      keep_elem_refs(pForm, data, pdata) 
 1051      retval = _fl_set_form_atdeactivate(pForm, c_FormAtdeactivate, pdata) 
 1052      return retval 
 1053   
 1054   
 1055 -def fl_unfreeze_form(pForm): 
 1056      """ 
 1057          fl_unfreeze_form(pForm) 
 1058   
 1059          All changes made in the meantime in a form are drawn at once, 
 1060          reverting previous freeze. 
 1061   
 1062          @param pForm : pointer to form to be re-drawn after freezing 
 1063      """ 
 1064   
 1065      _fl_unfreeze_form = cfuncproto( 
 1066              load_so_libforms(), "fl_unfreeze_form", \ 
 1067              None, [cty.POINTER(FL_FORM)], \ 
 1068              """void fl_unfreeze_form(FL_FORM * form) 
 1069              """) 
 1070      keep_elem_refs(pForm) 
 1071      _fl_unfreeze_form(pForm) 
 1072   
 1073   
 1074 -def fl_deactivate_form(pForm): 
 1075      """ 
 1076          fl_deactivate_form(pForm) 
 1077   
 1078          Deactivates form temporarily, without hiding it, but not allowing the 
 1079          user to interact with elements contained in form (buttons, etc.). 
 1080   
 1081          @param pForm : pointer to form to be de-activated 
 1082      """ 
 1083   
 1084      _fl_deactivate_form = cfuncproto( 
 1085              load_so_libforms(), "fl_deactivate_form", \ 
 1086              None, [cty.POINTER(FL_FORM)], \ 
 1087              """void fl_deactivate_form(FL_FORM * form) 
 1088              """) 
 1089      keep_elem_refs(pForm) 
 1090      _fl_deactivate_form(pForm) 
 1091   
 1092   
 1093 -def fl_activate_form(pForm): 
 1094      """ 
 1095          fl_activate_form(pForm) 
 1096   
 1097          (Re)activates form, allowing the user to interact again with elements 
 1098          contained in form (buttons, etc.). 
 1099   
 1100          @param pForm : pointer to form to be re-activated 
 1101      """ 
 1102   
 1103      _fl_activate_form = cfuncproto( 
 1104              load_so_libforms(), "fl_activate_form", \ 
 1105              None, [cty.POINTER(FL_FORM)], \ 
 1106              """void fl_activate_form(FL_FORM * form) 
 1107              """) 
 1108      keep_elem_refs(pForm) 
 1109      _fl_activate_form(pForm) 
 1110   
 1111   
 1112 -def fl_deactivate_all_forms(): 
 1113      """ 
 1114          fl_deactivate_all_forms() 
 1115   
 1116          De-activates all current forms, forbidding any user interactions. 
 1117      """ 
 1118   
 1119      _fl_deactivate_all_forms = cfuncproto( 
 1120              load_so_libforms(), "fl_deactivate_all_forms", \ 
 1121              None, [], \ 
 1122              """void fl_deactivate_all_forms() 
 1123              """) 
 1124      _fl_deactivate_all_forms() 
 1125   
 1126   
 1127 -def fl_activate_all_forms(): 
 1128      """ 
 1129          fl_activate_all_forms() 
 1130   
 1131          (Re)activates all current forms, allowing user interaction. 
 1132      """ 
 1133   
 1134      _fl_activate_all_forms = cfuncproto( 
 1135              load_so_libforms(), "fl_activate_all_forms", \ 
 1136              None, [], \ 
 1137              """void fl_activate_all_forms() 
 1138              """) 
 1139      _fl_activate_all_forms() 
 1140   
 1141   
 1142 -def fl_freeze_all_forms(): 
 1143      """ 
 1144          fl_freeze_all_forms() 
 1145   
 1146          It does not temporarily redraw all current forms while changes are 
 1147          being made, so all changes made are instead buffered internally. 
 1148      """ 
 1149   
 1150      _fl_freeze_all_forms = cfuncproto( 
 1151              load_so_libforms(), "fl_freeze_all_forms", \ 
 1152              None, [], \ 
 1153              """void fl_freeze_all_forms() 
 1154              """) 
 1155      _fl_freeze_all_forms() 
 1156   
 1157   
 1158 -def fl_unfreeze_all_forms(): 
 1159      """ 
 1160          fl_unfreeze_all_forms() 
 1161   
 1162          All changes made in the meantime in all current forms are drawn at 
 1163          once, reverting previous freeze. 
 1164      """ 
 1165   
 1166      _fl_unfreeze_all_forms = cfuncproto( 
 1167              load_so_libforms(), "fl_unfreeze_all_forms", \ 
 1168              None, [], \ 
 1169              """void fl_unfreeze_all_forms() 
 1170              """) 
 1171      _fl_unfreeze_all_forms() 
 1172   
 1173   
 1174 -def fl_scale_form(pForm, xsc, ysc): 
 1175      """ 
 1176          fl_scale_form(pForm, xsc, ysc) 
 1177   
 1178          Scales a form and the objects on it in size and position, indicating 
 1179          a scaling factor in x- and y-direction with respect to the current 
 1180          size, and reshapes the window. 
 1181   
 1182          @param pForm : pointer to form to be scaled 
 1183          @param xsc : scaling factor in horizontal direction 
 1184          @param ysc : scaling factor in vertical direction 
 1185      """ 
 1186   
 1187      _fl_scale_form = cfuncproto( 
 1188              load_so_libforms(), "fl_scale_form", \ 
 1189              None, [cty.POINTER(FL_FORM), cty.c_double, cty.c_double], \ 
 1190              """void fl_scale_form(FL_FORM * form, double xsc, double ysc) 
 1191              """) 
 1192      fxsc = convert_to_double(xsc) 
 1193      fysc = convert_to_double(ysc) 
 1194      keep_elem_refs(pForm, xsc, fxsc, ysc, fysc) 
 1195      _fl_scale_form(pForm, fxsc, fysc) 
 1196   
 1197   
 1198 -def fl_set_form_position(pForm, x, y): 
 1199      """ 
 1200          fl_set_form_position(pForm, x, y) 
 1201   
 1202          Sets position of form, when placing a form on the screen with 
 1203          FL_PLACE_GEOMETRY as place argument. 
 1204   
 1205          @param pForm : pointer to form whose position is to be set 
 1206          @param x : horizontal position 
 1207          @param y : vertical position 
 1208      """ 
 1209   
 1210      _fl_set_form_position = cfuncproto( 
 1211              load_so_libforms(), "fl_set_form_position", \ 
 1212              None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 
 1213              """void fl_set_form_position(FL_FORM * form, FL_Coord x, 
 1214                 FL_Coord y) 
 1215              """) 
 1216      ix = convert_to_FL_Coord(x) 
 1217      iy = convert_to_FL_Coord(y) 
 1218      keep_elem_refs(pForm, x, ix, y, iy) 
 1219      _fl_set_form_position(pForm, ix, iy) 
 1220   
 1221   
 1222 -def fl_set_form_title(pForm, name): 
 1223      """ 
 1224          fl_set_form_title(pForm, name) 
 1225   
 1226          Changes the form title (and the icon name) after it is shown. 
 1227   
 1228          @param pForm : pointer to form whose title has to be changed 
 1229          @param name : new name for the form 
 1230      """ 
 1231   
 1232      _fl_set_form_title = cfuncproto( 
 1233              load_so_libforms(), "fl_set_form_title", \ 
 1234              None, [cty.POINTER(FL_FORM), STRING], \ 
 1235              """void fl_set_form_title(FL_FORM * form, const char * name) 
 1236              """) 
 1237      sname = convert_to_string(name) 
 1238      keep_elem_refs(pForm, name, sname) 
 1239      _fl_set_form_title(pForm, sname) 
 1240   
 1241   
 1242 -def fl_set_app_mainform(pForm): 
 1243      """ fl_set_app_mainform(pForm) 
 1244      """ 
 1245   
 1246      _fl_set_app_mainform = cfuncproto( 
 1247              load_so_libforms(), "fl_set_app_mainform", 
 1248              None, [cty.POINTER(FL_FORM)], \ 
 1249              """void fl_set_app_mainform(FL_FORM * form) 
 1250              """) 
 1251      keep_elem_refs(pForm) 
 1252      _fl_set_app_mainform(pForm) 
 1253   
 1254   
 1255 -def fl_get_app_mainform(): 
 1256      """ fl_get_app_mainform() -> pForm 
 1257      """ 
 1258   
 1259      _fl_get_app_mainform = cfuncproto( 
 1260              load_so_libforms(), "fl_get_app_mainform", 
 1261              cty.POINTER(FL_FORM), [], \ 
 1262              """FL_FORM * fl_get_app_mainform() 
 1263              """) 
 1264      retval = _fl_get_app_mainform() 
 1265      return retval 
 1266   
 1267   
 1268 -def fl_set_app_nomainform(flag): 
 1269      """ fl_set_app_nomainform(flag) 
 1270      """ 
 1271   
 1272      _fl_set_app_nomainform = cfuncproto( 
 1273              load_so_libforms(), "fl_set_app_nomainform", 
 1274              None, [cty.c_int], \ 
 1275              """void fl_set_app_nomainform(int flag) 
 1276              """) 
 1277      iflag = convert_to_int(flag) 
 1278      keep_elem_refs(flag, iflag) 
 1279      _fl_set_app_nomainform(iflag) 
 1280   
 1281   
 1282  #already defined in xfdata 
 1283  #FL_FORMCALLBACKPTR = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), cty.c_void_p) 
 1284   
 1285 -def fl_set_form_callback(pForm, py_FormCallbackPtr, data): 
 1286      """ fl_set_form_callback(pForm, py_FormCallbackPtr, data) 
 1287   
 1288          Sets the callback routine for the form. 
 1289   
 1290          @param pForm : pointer to form 
 1291          @param py_FormCallbackPtr : python callback to be set, 
 1292             fn(pObject, ptr_void) 
 1293          @param data : argument to be passed to function 
 1294      """ 
 1295   
 1296      _fl_set_form_callback = cfuncproto( 
 1297              load_so_libforms(), "fl_set_form_callback", \ 
 1298              None, [cty.POINTER(FL_FORM), FL_FORMCALLBACKPTR, cty.c_void_p], \ 
 1299              """void fl_set_form_callback(FL_FORM * form, 
 1300                 FL_FORMCALLBACKPTR callback, void * d) 
 1301              """) 
 1302      c_FormCallbackPtr = FL_FORMCALLBACKPTR(py_FormCallbackPtr) 
 1303      pdata = cty.cast(data, cty.c_void_p) 
 1304      keep_cfunc_refs(c_FormCallbackPtr, py_FormCallbackPtr) 
 1305      keep_elem_refs(pForm, data, pdata) 
 1306      _fl_set_form_callback(pForm, c_FormCallbackPtr, pdata) 
 1307   
 1308   
 1309  fl_set_form_call_back = fl_set_form_callback 
 1310   
 1311   
 1312 -def fl_set_form_size(pForm, w, h): 
 1313      """ 
 1314          fl_set_form_size(pForm, w, h) 
 1315   
 1316          Sets the size of form. 
 1317   
 1318          @param pForm : pointer to form 
 1319          @param w : width of form 
 1320          @param h : height of form 
 1321      """ 
 1322   
 1323      _fl_set_form_size = cfuncproto( 
 1324              load_so_libforms(), "fl_set_form_size", \ 
 1325              None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 
 1326              """void fl_set_form_size(FL_FORM * form, FL_Coord w, FL_Coord h) 
 1327              """) 
 1328      iw = convert_to_FL_Coord(w) 
 1329      ih = convert_to_FL_Coord(h) 
 1330      keep_elem_refs(pForm, w, iw, h, ih) 
 1331      _fl_set_form_size(pForm, iw, ih) 
 1332   
 1333   
 1334 -def fl_set_form_hotspot(pForm, x, y): 
 1335      """ 
 1336          fl_set_form_hotspot(pForm, x, y) 
 1337   
 1338          Sets the position of the hotspot of a form. 
 1339   
 1340          @param pForm : pointer to form 
 1341          @param x : horizontal position 
 1342          @param y : vertical position 
 1343      """ 
 1344   
 1345      _fl_set_form_hotspot = cfuncproto( 
 1346              load_so_libforms(), "fl_set_form_hotspot", \ 
 1347              None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 
 1348              """void fl_set_form_hotspot(FL_FORM * form, FL_Coord x, 
 1349                 FL_Coord y) 
 1350              """) 
 1351      ix = convert_to_FL_Coord(x) 
 1352      iy = convert_to_FL_Coord(y) 
 1353      keep_elem_refs(pForm, x, ix, y, iy) 
 1354      _fl_set_form_hotspot(pForm, ix, iy) 
 1355   
 1356   
 1357 -def fl_set_form_hotobject(pForm, pObject): 
 1358      """ 
 1359          fl_set_form_hotobject(pForm, pObject) 
 1360   
 1361          @param pForm : pointer to form 
 1362          @param pObject : pointer to object 
 1363      """ 
 1364   
 1365      _fl_set_form_hotobject = cfuncproto( 
 1366              load_so_libforms(), "fl_set_form_hotobject", \ 
 1367              None, [cty.POINTER(FL_FORM), cty.POINTER(FL_OBJECT)], \ 
 1368              """void fl_set_form_hotobject(FL_FORM * form, FL_OBJECT * ob) 
 1369              """) 
 1370      keep_elem_refs(pForm, pObject) 
 1371      _fl_set_form_hotobject(pForm, pObject) 
 1372   
 1373   
 1374 -def fl_set_form_minsize(pForm, w, h): 
 1375      """ 
 1376          fl_set_form_minsize(pForm, w, h) 
 1377   
 1378          @param pForm : pointer to form 
 1379          @param w : width of form 
 1380          @param h : height of form 
 1381      """ 
 1382   
 1383      _fl_set_form_minsize = cfuncproto( 
 1384              load_so_libforms(), "fl_set_form_minsize", \ 
 1385              None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 
 1386              """void fl_set_form_minsize(FL_FORM * form, FL_Coord w, FL_Coord h) 
 1387              """) 
 1388      iw = convert_to_FL_Coord(w) 
 1389      ih = convert_to_FL_Coord(h) 
 1390      keep_elem_refs(pForm, w, iw, h, ih) 
 1391      _fl_set_form_minsize(pForm, iw, ih) 
 1392   
 1393   
 1394 -def fl_set_form_maxsize(pForm, w, h): 
 1395      """ 
 1396          fl_set_form_maxsize(pForm, w, h) 
 1397   
 1398          @param pForm : pointer to form 
 1399          @param w : width of form 
 1400          @param h : height of form 
 1401      """ 
 1402   
 1403      _fl_set_form_maxsize = cfuncproto( 
 1404              load_so_libforms(), "fl_set_form_maxsize", \ 
 1405              None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 
 1406              """void fl_set_form_maxsize(FL_FORM * form, FL_Coord w, FL_Coord h) 
 1407              """) 
 1408      iw = convert_to_FL_Coord(w) 
 1409      ih = convert_to_FL_Coord(h) 
 1410      keep_elem_refs(pForm, w, iw, h, ih) 
 1411      _fl_set_form_maxsize(pForm, iw, ih) 
 1412   
 1413   
 1414 -def fl_set_form_event_cmask(pForm, cmask): 
 1415      """ 
 1416          fl_set_form_event_cmask(pForm, cmask) 
 1417   
 1418          @param pForm : pointer to form 
 1419          @param cmask : compress mask for form 
 1420      """ 
 1421   
 1422      _fl_set_form_event_cmask = cfuncproto( 
 1423              load_so_libforms(), "fl_set_form_event_cmask", \ 
 1424              None, [cty.POINTER(FL_FORM), cty.c_ulong], \ 
 1425              """void fl_set_form_event_cmask(FL_FORM * form, 
 1426                 long unsigned int cmask) 
 1427              """) 
 1428      ulcmask = convert_to_ulong(cmask) 
 1429      keep_elem_refs(pForm, cmask, ulcmask) 
 1430      _fl_set_form_event_cmask(pForm, ulcmask) 
 1431   
 1432   
 1433 -def fl_get_form_event_cmask(pForm): 
 1434      """ 
 1435          fl_get_form_event_cmask(pForm) -> cmask ID 
 1436   
 1437          @param pForm : pointer to form 
 1438          @returns : compress mask for form 
 1439      """ 
 1440   
 1441      _fl_get_form_event_cmask = cfuncproto( 
 1442              load_so_libforms(), "fl_get_form_event_cmask", \ 
 1443              cty.c_ulong, [cty.POINTER(FL_FORM)], \ 
 1444              """long unsigned int fl_get_form_event_cmask(FL_FORM * form) 
 1445              """) 
 1446      keep_elem_refs(pForm) 
 1447      retval = _fl_get_form_event_cmask(pForm) 
 1448      return retval 
 1449   
 1450   
 1451  # alert until upstream bugfix 
 1452 -def fl_set_form_geometry(pForm, x, y, w, h): 
 1453      """ 
 1454          fl_set_form_geometry(pForm, x, y, w, h) 
 1455   
 1456          @param pForm : pointer to form 
 1457          @param x : horizontal position 
 1458          @param y : vertical position 
 1459          @param w : width of form 
 1460          @param h : height of form 
 1461      """ 
 1462   
 1463      _fl_set_form_geometry = cfuncproto( 
 1464              load_so_libforms(), "fl_set_form_geometry", \ 
 1465              None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord, 
 1466              FL_Coord, FL_Coord], \ 
 1467              """void fl_set_form_geometry(FL_FORM * form, FL_Coord x, 
 1468                 FL_Coord y, FL_Coord w, FL_Coord h) 
 1469              """) 
 1470      ix = convert_to_FL_Coord(x) 
 1471      iy = convert_to_FL_Coord(y) 
 1472      iw = convert_to_FL_Coord(w) 
 1473      ih = convert_to_FL_Coord(h) 
 1474      keep_elem_refs(pForm, x, ix, y, iy, w, iw, h, ih) 
 1475      _fl_set_form_geometry(pForm, ix, iy, iw, ih) 
 1476   
 1477   
 1478  fl_set_initial_placement = fl_set_form_geometry 
 1479   
 1480   
 1481 -def fl_show_form(pForm, place, border, title): 
 1482      """ 
 1483          fl_show_form(pForm, place, border, title) -> window id 
 1484   
 1485          Shows the form. 
 1486   
 1487          @param pForm : pointer to form 
 1488          @param place : where form has to be placed 
 1489          @param border : type of window manager decoration 
 1490          @param title : title of form 
 1491      """ 
 1492   
 1493      _fl_show_form = cfuncproto( 
 1494              load_so_libforms(), "fl_show_form", 
 1495              Window, [cty.POINTER(FL_FORM), cty.c_int, cty.c_int, STRING], \ 
 1496              """Window fl_show_form(FL_FORM * form, int place, int border, 
 1497                 const char * name) 
 1498              """) 
 1499      check_admitted_listvalues(place, PLACE_list) 
 1500      check_admitted_listvalues(border, DECORATION_list) 
 1501      iplace = convert_to_int(place) 
 1502      iborder = convert_to_int(border) 
 1503      stitle = convert_to_string(title) 
 1504      keep_elem_refs(pForm, place, iplace, border, iborder, title, stitle) 
 1505      retval = _fl_show_form(pForm, iplace, iborder, stitle) 
 1506      return retval 
 1507   
 1508   
 1509 -def fl_hide_form(pForm): 
 1510      """ 
 1511          fl_hide_form(pForm) 
 1512   
 1513          Hides the form. 
 1514   
 1515          @param pForm : pointer to form 
 1516      """ 
 1517   
 1518      _fl_hide_form = cfuncproto( 
 1519              load_so_libforms(), "fl_hide_form", 
 1520              None, [cty.POINTER(FL_FORM)], \ 
 1521              """void fl_hide_form(FL_FORM * form) 
 1522              """) 
 1523      keep_elem_refs(pForm) 
 1524      _fl_hide_form(pForm) 
 1525   
 1526   
 1527 -def fl_free_form(pForm): 
 1528      """ 
 1529          fl_free_form(pForm) 
 1530   
 1531          Frees the memory used by a form together with all its objects. 
 1532   
 1533          @param pForm : pointer to form to be freed 
 1534      """ 
 1535   
 1536      _fl_free_form = cfuncproto( 
 1537              load_so_libforms(), "fl_free_form", 
 1538              None, [cty.POINTER(FL_FORM)], \ 
 1539              """void fl_free_form(FL_FORM * form) 
 1540              """) 
 1541      keep_elem_refs(pForm) 
 1542      _fl_free_form(pForm) 
 1543   
 1544   
 1545 -def fl_redraw_form(pForm): 
 1546      """ 
 1547          fl_redraw_form(pForm) 
 1548   
 1549          Draws a form. 
 1550   
 1551          @param pForm : pointer to form 
 1552      """ 
 1553   
 1554      _fl_redraw_form = cfuncproto( 
 1555              load_so_libforms(), "fl_redraw_form", 
 1556              None, [cty.POINTER(FL_FORM)], \ 
 1557              """void fl_redraw_form(FL_FORM * form) 
 1558              """) 
 1559      keep_elem_refs(pForm) 
 1560      _fl_redraw_form(pForm) 
 1561   
 1562   
 1563 -def fl_set_form_dblbuffer(pForm, y): 
 1564      """ 
 1565          fl_set_form_dblbuffer(pForm, y) 
 1566   
 1567          @param pForm : pointer to form 
 1568          @param y : flag (0|1) for disabling/enabling doublebuffer 
 1569      """ 
 1570   
 1571      _fl_set_form_dblbuffer = cfuncproto( 
 1572              load_so_libforms(), "fl_set_form_dblbuffer", \ 
 1573              None, [cty.POINTER(FL_FORM), cty.c_int], \ 
 1574              """void fl_set_form_dblbuffer(FL_FORM * form, int y) 
 1575              """) 
 1576      iy = convert_to_int(y) 
 1577      keep_elem_refs(pForm, y, iy) 
 1578      _fl_set_form_dblbuffer(pForm, iy) 
 1579   
 1580   
 1581 -def fl_prepare_form_window(pForm, place, border, name): 
 1582      """ 
 1583          fl_prepare_form_window(pForm, place, border, name) -> window ID 
 1584   
 1585          Displays a particular form, returns its window handle. 
 1586   
 1587          @param pForm : pointer to form 
 1588          @param place : where has to be placed 
 1589          @param border : window manager decoration 
 1590          @param name : title of form 
 1591      """ 
 1592   
 1593      _fl_prepare_form_window = cfuncproto( 
 1594              load_so_libforms(), "fl_prepare_form_window", \ 
 1595              Window, [cty.POINTER(FL_FORM), cty.c_int, cty.c_int, STRING], \ 
 1596              """Window fl_prepare_form_window(FL_FORM * form, int place, 
 1597                 int border, const char * name) 
 1598              """) 
 1599      iplace = convert_to_int(place) 
 1600      iborder = convert_to_int(border) 
 1601      sname = convert_to_string(name) 
 1602      keep_elem_refs(pForm, place, iplace, border, iborder, name, sname) 
 1603      retval = _fl_prepare_form_window(pForm, iplace, iborder, sname) 
 1604      return retval 
 1605   
 1606   
 1607 -def fl_show_form_window(pForm): 
 1608      """ 
 1609          fl_show_form_window(pForm) -> window ID 
 1610   
 1611          @param pForm : pointer to form 
 1612      """ 
 1613   
 1614      _fl_show_form_window = cfuncproto( 
 1615              load_so_libforms(), "fl_show_form_window", \ 
 1616              Window, [cty.POINTER(FL_FORM)], \ 
 1617              """Window fl_show_form_window(FL_FORM * form) 
 1618              """) 
 1619      keep_elem_refs(pForm) 
 1620      retval = _fl_show_form_window(pForm) 
 1621      return retval 
 1622   
 1623   
 1624 -def fl_adjust_form_size(pForm): 
 1625      """ 
 1626          fl_adjust_form_size(pForm) -> max_factor id 
 1627   
 1628          Similar to fl_fit_object_label, but will do it for all objects and 
 1629          has a smaller threshold. Mainly intended for compensation for font 
 1630          size variations. 
 1631   
 1632          @param pForm : pointer to form 
 1633      """ 
 1634   
 1635      _fl_adjust_form_size = cfuncproto( 
 1636              load_so_libforms(), "fl_adjust_form_size", \ 
 1637              cty.c_double, [cty.POINTER(FL_FORM)], \ 
 1638              """double fl_adjust_form_size(FL_FORM * form) 
 1639              """) 
 1640      keep_elem_refs(pForm) 
 1641      retval = _fl_adjust_form_size(pForm) 
 1642      return retval 
 1643   
 1644   
 1645 -def fl_form_is_visible(pForm): 
 1646      """ 
 1647          fl_form_is_visible(pForm) -> state id 
 1648   
 1649          Returns if form is visible. 
 1650   
 1651          @param pForm : pointer to form 
 1652      """ 
 1653   
 1654      _fl_form_is_visible = cfuncproto( 
 1655              load_so_libforms(), "fl_form_is_visible", \ 
 1656              cty.c_int, [cty.POINTER(FL_FORM)], \ 
 1657              """int fl_form_is_visible(FL_FORM * form) 
 1658              """) 
 1659      keep_elem_refs(pForm) 
 1660      retval = _fl_form_is_visible(pForm) 
 1661      return retval 
 1662   
 1663   
 1664 -def fl_form_is_iconified(pForm): 
 1665      """ 
 1666          fl_form_is_iconified(pForm) -> state id 
 1667   
 1668          Returns if a forms window is in iconified state. 
 1669   
 1670          @param pForm : pointer to form 
 1671      """ 
 1672   
 1673      _fl_form_is_iconified = cfuncproto( 
 1674              load_so_libforms(), "fl_form_is_iconified", \ 
 1675              cty.c_int, [cty.POINTER(FL_FORM)], \ 
 1676              """int fl_form_is_iconified(FL_FORM * form) 
 1677              """) 
 1678      keep_elem_refs(pForm) 
 1679      retval = _fl_form_is_iconified(pForm) 
 1680      return retval 
 1681   
 1682   
 1683  #already defined in xfdata 
 1684  #FL_RAW_CALLBACK = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_FORM), cty.c_void_p) 
 1685   
 1686 -def fl_register_raw_callback(pForm, mask, py_RawCallback): 
 1687      """ 
 1688          fl_register_raw_callback(pForm, mask, py_RawCallback) -> old raw_callback func. 
 1689   
 1690          Register pre-emptive event handlers. 
 1691   
 1692          @param pForm : pointer to form 
 1693          @param mask : key/button/window event mask (press, release, motion, 
 1694             enter, leave etc..) 
 1695          @param py_RawCallback : python callback function, 
 1696             fn(pForm, ptr_void) -> num 
 1697      """ 
 1698   
 1699      _fl_register_raw_callback = cfuncproto( 
 1700              load_so_libforms(), "fl_register_raw_callback", \ 
 1701              FL_RAW_CALLBACK, [cty.POINTER(FL_FORM), cty.c_ulong, 
 1702              FL_RAW_CALLBACK], \ 
 1703              """FL_RAW_CALLBACK fl_register_raw_callback(FL_FORM * form, 
 1704                 long unsigned int mask, FL_RAW_CALLBACK rcb) 
 1705              """) 
 1706      ulmask = convert_to_ulong(mask) 
 1707      c_RawCallback = FL_RAW_CALLBACK(py_RawCallback) 
 1708      keep_cfunc_refs(c_RawCallback, py_RawCallback) 
 1709      keep_elem_refs(pForm, mask, ulmask) 
 1710      retval = _fl_register_raw_callback(pForm, ulmask, c_RawCallback) 
 1711      return retval 
 1712   
 1713   
 1714  fl_register_call_back = fl_register_raw_callback 
 1715   
 1716   
 1717 -def fl_bgn_group(): 
 1718      """ 
 1719          fl_bgn_group() -> pObject 
 1720   
 1721          Starts a group definition. 
 1722      """ 
 1723   
 1724      _fl_bgn_group = cfuncproto( 
 1725              load_so_libforms(), "fl_bgn_group", \ 
 1726              cty.POINTER(FL_OBJECT), [], \ 
 1727              """FL_OBJECT * fl_bgn_group() 
 1728              """) 
 1729      retval = _fl_bgn_group() 
 1730      return retval 
 1731   
 1732   
 1733 -def fl_end_group(): 
 1734      """ 
 1735          fl_end_group() 
 1736   
 1737          Ends a group definition. 
 1738      """ 
 1739   
 1740      _fl_end_group = cfuncproto( 
 1741              load_so_libforms(), "fl_end_group", \ 
 1742              None, [], \ 
 1743              """void fl_end_group() 
 1744              """) 
 1745      _fl_end_group() 
 1746   
 1747   
 1748 -def fl_addto_group(pGroup): 
 1749      """ 
 1750          fl_addto_group(pGroup) -> pForm 
 1751   
 1752          Reopens a group to allow addition of further objects. 
 1753   
 1754          @param pGroup : pointer to group object to reopen 
 1755      """ 
 1756   
 1757      _fl_addto_group = cfuncproto( 
 1758              load_so_libforms(), "fl_addto_group", \ 
 1759              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], \ 
 1760              """FL_OBJECT * fl_addto_group(FL_OBJECT * group) 
 1761              """) 
 1762      keep_elem_refs(pGroup) 
 1763      retval = _fl_addto_group(pGroup) 
 1764      return retval 
 1765   
 1766   
 1767  # Routines that deal with FL_OBJECTS 
 1768   
 1769   
 1770 -def fl_get_object_objclass(pObject): 
 1771      """ 
 1772          fl_get_object_objclass(pObject) -> objclass id 
 1773   
 1774          Return the objclass of an object. 
 1775   
 1776          @param pObject : pointer to object 
 1777      """ 
 1778   
 1779      _fl_get_object_objclass = cfuncproto( 
 1780              load_so_libforms(), "fl_get_object_obclass", \ 
 1781              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 1782              """int fl_get_object_objclass(FL_OBJECT * obj) 
 1783              """) 
 1784      keep_elem_refs(pObject) 
 1785      retval = _fl_get_object_objclass(pObject) 
 1786      return retval 
 1787   
 1788   
 1789 -def fl_get_object_type(pObject): 
 1790      """ 
 1791          fl_get_object_type(pObject) -> type id 
 1792   
 1793          Return the type of an object. 
 1794   
 1795          @param pObject : pointer to object 
 1796      """ 
 1797   
 1798      _fl_get_object_type = cfuncproto( 
 1799              load_so_libforms(), "fl_get_object_type", \ 
 1800              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 1801              """int fl_get_object_type(FL_OBJECT * obj) 
 1802              """) 
 1803      keep_elem_refs(pObject) 
 1804      retval = _fl_get_object_type(pObject) 
 1805      return retval 
 1806   
 1807   
 1808 -def fl_set_object_boxtype(pObject, boxtype): 
 1809      """ 
 1810          fl_set_object_boxtype(pObject, boxtype) 
 1811   
 1812          Sets the type of box of an object. 
 1813   
 1814          @param pObject : pointer to object 
 1815          @param boxtype : type of the box 
 1816      """ 
 1817   
 1818      _fl_set_object_boxtype = cfuncproto( 
 1819              load_so_libforms(), "fl_set_object_boxtype", \ 
 1820              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 1821              """void fl_set_object_boxtype(FL_OBJECT * ob, int boxtype) 
 1822              """) 
 1823      check_admitted_listvalues(boxtype, BOXTYPE_list) 
 1824      iboxtype = convert_to_int(boxtype) 
 1825      keep_elem_refs(pObject, boxtype, iboxtype) 
 1826      _fl_set_object_boxtype(pObject, iboxtype) 
 1827   
 1828   
 1829 -def fl_get_object_boxtype(pObject): 
 1830      """ 
 1831          fl_get_object_boxtype(pObject) -> boxtype id 
 1832   
 1833          Return the boxtype of an object. 
 1834   
 1835          @param pObject : pointer to object 
 1836      """ 
 1837   
 1838      _fl_get_object_boxtype = cfuncproto( 
 1839              load_so_libforms(), "fl_get_object_boxtype", \ 
 1840              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 1841              """int fl_get_object_boxtype(FL_OBJECT * obj) 
 1842              """) 
 1843      keep_elem_refs(pObject) 
 1844      retval = _fl_get_object_boxtype(pObject) 
 1845      return retval 
 1846   
 1847   
 1848 -def fl_set_object_bw(pObject, bw): 
 1849      """ 
 1850          fl_set_object_bw(pObject, bw) 
 1851   
 1852          Sets the borderwidth of an object. 
 1853   
 1854          @param pObject : pointer to object 
 1855          @param bw : borderwidth of object 
 1856      """ 
 1857   
 1858      _fl_set_object_bw = cfuncproto( 
 1859              load_so_libforms(), "fl_set_object_bw", \ 
 1860              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 1861              """void fl_set_object_bw(FL_OBJECT * ob, int bw) 
 1862              """) 
 1863      ibw = convert_to_int(bw) 
 1864      keep_elem_refs(pObject, bw, ibw) 
 1865      _fl_set_object_bw(pObject, ibw) 
 1866   
 1867   
 1868  #def fl_get_object_bw(pObject, bw)       *API change* 
 1869 -def fl_get_object_bw(pObject): 
 1870      """ 
 1871          fl_get_object_bw(pObject) -> bw 
 1872   
 1873          Returns the borderwidth of an object. 
 1874   
 1875          @param pObject : pointer to object 
 1876      """ 
 1877   
 1878      _fl_get_object_bw = cfuncproto( 
 1879              load_so_libforms(), "fl_get_object_bw", \ 
 1880              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int)], \ 
 1881              """void fl_get_object_bw(FL_OBJECT * ob, int * bw) 
 1882              """) 
 1883      bw, pbw = make_int_and_pointer() 
 1884      keep_elem_refs(pObject, bw, pbw) 
 1885      _fl_get_object_bw(pObject, pbw) 
 1886      return bw 
 1887   
 1888   
 1889 -def fl_set_object_resize(pObject, what): 
 1890      """ 
 1891          fl_set_object_resize(pObject, what) 
 1892   
 1893          Sets the resize property of an object. 
 1894   
 1895          @param pObject : pointer to object 
 1896          @param what : resize property 
 1897      """ 
 1898   
 1899      _fl_set_object_resize = cfuncproto( 
 1900              load_so_libforms(), "fl_set_object_resize", \ 
 1901              None, [cty.POINTER(FL_OBJECT), cty.c_uint], \ 
 1902              """void fl_set_object_resize(FL_OBJECT * ob, unsigned int what) 
 1903              """) 
 1904      uiwhat = convert_to_uint(what) 
 1905      keep_elem_refs(pObject, what, uiwhat) 
 1906      _fl_set_object_resize(pObject, uiwhat) 
 1907   
 1908   
 1909  #def fl_get_object_resize(pObject, what)       *API change* 
 1910 -def fl_get_object_resize(pObject): 
 1911      """ 
 1912          fl_get_object_resize(pObject) -> what 
 1913   
 1914          Returns the resize property of an object. 
 1915   
 1916          @param pObject : pointer to object 
 1917      """ 
 1918   
 1919      _fl_get_object_resize = cfuncproto( 
 1920              load_so_libforms(), "fl_get_object_resize", \ 
 1921               None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_uint)], \ 
 1922              """void fl_get_object_resize(FL_OBJECT * ob, unsigned int * what) 
 1923              """) 
 1924      what, pwhat = make_uint_and_pointer() 
 1925      keep_elem_refs(pObject, what, pwhat) 
 1926      _fl_get_object_resize(pObject, pwhat) 
 1927      return what 
 1928   
 1929   
 1930 -def fl_set_object_gravity(pObject, nw, se): 
 1931      """ 
 1932          fl_set_object_gravity(pObject, nw, se) 
 1933   
 1934          Sets the gravity properties of an object. 
 1935   
 1936          @param pObject : pointer to object 
 1937          @param nw : gravity property for NorthWest 
 1938          @param se : gravity property for SouthEast 
 1939      """ 
 1940   
 1941      _fl_set_object_gravity = cfuncproto( 
 1942              load_so_libforms(), "fl_set_object_gravity", \ 
 1943              None, [cty.POINTER(FL_OBJECT), cty.c_uint, cty.c_uint], \ 
 1944              """void fl_set_object_gravity(FL_OBJECT * ob, unsigned int nw, 
 1945                 unsigned int se) 
 1946              """) 
 1947      uinw = convert_to_uint(nw) 
 1948      uise = convert_to_uint(se) 
 1949      keep_elem_refs(pObject, nw, uinw, se, uise) 
 1950      _fl_set_object_gravity(pObject, uinw, uise) 
 1951   
 1952   
 1953  #def fl_get_object_gravity(pObject, nw, se)       *API change* 
 1954 -def fl_get_object_gravity(pObject): 
 1955      """ 
 1956          fl_get_object_gravity(pObject) -> nw, se 
 1957   
 1958          Returns the gravity properties of an object. 
 1959   
 1960          @param pObject : pointer to object 
 1961      """ 
 1962   
 1963      _fl_get_object_gravity = cfuncproto( 
 1964              load_so_libforms(), "fl_get_object_gravity", \ 
 1965              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_uint), 
 1966              cty.POINTER(cty.c_uint)], \ 
 1967              """void fl_get_object_gravity(FL_OBJECT * ob, unsigned int * nw, 
 1968                 unsigned int * se) 
 1969              """) 
 1970      nw, pnw = make_uint_and_pointer() 
 1971      se, pse = make_uint_and_pointer() 
 1972      keep_elem_refs(pObject, nw, se, pnw, pse) 
 1973      _fl_get_object_gravity(pObject, pnw, pse) 
 1974      return nw, se 
 1975   
 1976   
 1977 -def fl_set_object_lsize(pObject, lsize): 
 1978      """ 
 1979          fl_set_object_lsize(pObject, lsize) 
 1980   
 1981          Sets the label size of an object. 
 1982   
 1983          @param pObject : pointer to object 
 1984          @param lsize : label size 
 1985      """ 
 1986   
 1987      _fl_set_object_lsize = cfuncproto( 
 1988              load_so_libforms(), "fl_set_object_lsize", \ 
 1989              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 1990              """void fl_set_object_lsize(FL_OBJECT * ob, int lsize) 
 1991              """) 
 1992      ilsize = convert_to_int(lsize) 
 1993      keep_elem_refs(pObject, lsize, ilsize) 
 1994      _fl_set_object_lsize(pObject, ilsize) 
 1995   
 1996   
 1997 -def fl_get_object_lsize(pObject): 
 1998      """ 
 1999          fl_get_object_lsize(pObject) -> lsize num. 
 2000   
 2001          Returns the label size of an object. 
 2002   
 2003          @param pObject : pointer to object 
 2004      """ 
 2005   
 2006      _fl_get_object_lsize = cfuncproto( 
 2007              load_so_libforms(), "fl_get_object_lsize", \ 
 2008              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 2009              """int fl_get_object_lsize(FL_OBJECT * obj) 
 2010              """) 
 2011      keep_elem_refs(pObject) 
 2012      retval = _fl_get_object_lsize(pObject) 
 2013      return retval 
 2014   
 2015   
 2016 -def fl_set_object_lstyle(pObject, lstyle): 
 2017      """ 
 2018          fl_set_object_lstyle(pObject, lstyle) 
 2019   
 2020          Sets the label style of an object. 
 2021   
 2022          @param pObject : pointer to object 
 2023          @param lstyle : label style 
 2024      """ 
 2025   
 2026      _fl_set_object_lstyle = cfuncproto( 
 2027              load_so_libforms(), "fl_set_object_lstyle", \ 
 2028              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 2029              """void fl_set_object_lstyle(FL_OBJECT * ob, int lstyle) 
 2030              """) 
 2031      check_admitted_listvalues(lstyle, TEXTSTYLE_list) 
 2032      ilstyle = convert_to_int(lstyle) 
 2033      keep_elem_refs(pObject, lstyle, ilstyle) 
 2034      _fl_set_object_lstyle(pObject, ilstyle) 
 2035   
 2036   
 2037 -def fl_get_object_lstyle(pObject): 
 2038      """ 
 2039          fl_get_object_lstyle(pObject) -> lstyle num. 
 2040   
 2041          Returns the label style of an object. 
 2042   
 2043          @param pObject : pointer to object 
 2044      """ 
 2045   
 2046      _fl_get_object_lstyle = cfuncproto( 
 2047              load_so_libforms(), "fl_get_object_lstyle", \ 
 2048              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 2049              """int fl_get_object_lstyle(FL_OBJECT * obj) 
 2050              """) 
 2051      keep_elem_refs(pObject) 
 2052      retval = _fl_get_object_lstyle(pObject) 
 2053      return retval 
 2054   
 2055   
 2056 -def fl_set_object_lcol(pObject, lcolr): 
 2057      """ 
 2058          fl_set_object_lcol(pObject, lcolr) 
 2059   
 2060          Sets the label color of an object. 
 2061   
 2062          @param pObject : pointer to object 
 2063          @param lcolr : label color 
 2064      """ 
 2065   
 2066      _fl_set_object_lcol = cfuncproto( 
 2067              load_so_libforms(), "fl_set_object_lcol", \ 
 2068              None, [cty.POINTER(FL_OBJECT), FL_COLOR], \ 
 2069              """void fl_set_object_lcol(FL_OBJECT * ob, FL_COLOR lcol) 
 2070              """) 
 2071      check_admitted_listvalues(lcolr, COLOR_list) 
 2072      ullcolr = convert_to_FL_COLOR(lcolr) 
 2073      keep_elem_refs(pObject, lcolr, ullcolr) 
 2074      _fl_set_object_lcol(pObject, ullcolr) 
 2075   
 2076   
 2077 -def fl_get_object_lcol(pObject): 
 2078      """ 
 2079          fl_get_object_lcol(pObject) -> color 
 2080   
 2081          Returns the label color of an object. 
 2082   
 2083          @param pObject : pointer to object 
 2084      """ 
 2085   
 2086      _fl_get_object_lcol = cfuncproto( 
 2087              load_so_libforms(), "fl_get_object_lcol", \ 
 2088              FL_COLOR, [cty.POINTER(FL_OBJECT)], \ 
 2089              """FL_COLOR fl_set_object_lcol(FL_OBJECT * obj) 
 2090              """) 
 2091      keep_elem_refs(pObject) 
 2092      retval = _fl_get_object_lcol(pObject) 
 2093      return retval 
 2094   
 2095   
 2096 -def fl_set_object_return(pObject, when): 
 2097      """ 
 2098          fl_set_object_return(pObject, when) -> ID num 
 2099   
 2100          Function for setting the conditions under which an object gets 
 2101          returned (or its callback invoked). If the object has to do 
 2102          additional work on setting te condition (e.g. it has child 
 2103          objects that also need to be set) it has to set up it's own 
 2104          function that then will called in the end. This function should 
 2105          only be called once an object has been created completely! 
 2106   
 2107          @param pObject : pointer to object 
 2108          @param when : return type 
 2109      """ 
 2110   
 2111      _fl_set_object_return = cfuncproto( 
 2112              load_so_libforms(), "fl_set_object_return", \ 
 2113              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 2114              """int fl_set_object_return(FL_OBJECT * ob, int when)   DEPRECATED 
 2115              """) 
 2116      check_admitted_listvalues(when, RETURN_list) 
 2117      iwhen = convert_to_int(when) 
 2118      keep_elem_refs(pObject, when, iwhen) 
 2119      retval = _fl_set_object_return(pObject, iwhen) 
 2120      return retval 
 2121   
 2122   
 2123 -def fl_notify_object(pObject, cause): 
 2124      """ 
 2125          fl_notify_object(pObject, cause) 
 2126   
 2127          @param pObject : pointer to object 
 2128          @param cause : ? 
 2129      """ 
 2130   
 2131      _fl_notify_object = cfuncproto( 
 2132              load_so_libforms(), "fl_notify_object", \ 
 2133              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 2134              """void fl_notify_object(FL_OBJECT * obj, int cause) 
 2135              """) 
 2136      icause = convert_to_int(cause) 
 2137      keep_elem_refs(pObject, cause, icause) 
 2138      _fl_notify_object(pObject, icause) 
 2139   
 2140   
 2141 -def fl_set_object_lalign(pObject, align): 
 2142      """ 
 2143          fl_set_object_lalign(pObject, align) 
 2144   
 2145          Sets alignment of an object. 
 2146   
 2147          @param pObject : pointer to object 
 2148          @param align : alignment of object 
 2149      """ 
 2150   
 2151      _fl_set_object_lalign = cfuncproto( 
 2152              load_so_libforms(), "fl_set_object_lalign", \ 
 2153              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 2154              """void fl_set_object_lalign(FL_OBJECT * ob, int align) 
 2155              """) 
 2156      check_admitted_listvalues(align, ALIGN_list) 
 2157      ialign = convert_to_int(align) 
 2158      keep_elem_refs(pObject, align, ialign) 
 2159      _fl_set_object_lalign(pObject, ialign) 
 2160   
 2161   
 2162 -def fl_get_object_lalign(pObject): 
 2163      """ 
 2164          fl_get_object_lalign(pObject) -> align num. 
 2165   
 2166          Returns alignment of an object. 
 2167   
 2168          @param pObject : pointer to object 
 2169      """ 
 2170   
 2171      _fl_get_object_lalign = cfuncproto( 
 2172              load_so_libforms(), "fl_get_object_lalign", \ 
 2173              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 2174              """int fl_set_object_lalign(FL_OBJECT * ob) 
 2175              """) 
 2176      keep_elem_refs(pObject) 
 2177      retval = _fl_get_object_lalign(pObject) 
 2178      return retval 
 2179   
 2180   
 2181 -def fl_set_object_shortcut(pObject, sstr, showit): 
 2182      """ 
 2183          fl_set_object_shortcut(pObject, sstr, showit) 
 2184   
 2185          @param pObject : pointer to object 
 2186          @param sstr : shortcut string 
 2187          @param showit : flag (0|1) 
 2188      """ 
 2189   
 2190      _fl_set_object_shortcut = cfuncproto( 
 2191              load_so_libforms(), "fl_set_object_shortcut", \ 
 2192              None, [cty.POINTER(FL_OBJECT), STRING, cty.c_int], \ 
 2193              """void fl_set_object_shortcut(FL_OBJECT * obj, 
 2194                 const char * sstr, int showit) 
 2195              """) 
 2196      ssstr = convert_to_string(sstr) 
 2197      ishowit = convert_to_int(showit) 
 2198      keep_elem_refs(pObject, sstr, ssstr, showit, ishowit) 
 2199      _fl_set_object_shortcut(pObject, ssstr, ishowit) 
 2200   
 2201   
 2202 -def fl_set_object_shortcutkey(pObject, keysym): 
 2203      """ 
 2204          fl_set_object_shortcutkey(pObject, keysym) 
 2205   
 2206          @param pObject : pointer to object 
 2207          @param keysym : ? 
 2208      """ 
 2209   
 2210      _fl_set_object_shortcutkey = cfuncproto( 
 2211              load_so_libforms(), "fl_set_object_shortcutkey", 
 2212              None, [cty.POINTER(FL_OBJECT), cty.c_uint], \ 
 2213              """void fl_set_object_shortcutkey(FL_OBJECT * obj, 
 2214                 unsigned int keysym) 
 2215              """) 
 2216      uikeysym = convert_to_uint(keysym) 
 2217      keep_elem_refs(pObject, keysym, uikeysym) 
 2218      _fl_set_object_shortcutkey(pObject, uikeysym) 
 2219   
 2220   
 2221 -def fl_set_object_dblbuffer(pObject, y): 
 2222      """ 
 2223          fl_set_object_dblbuffer(pObject, y) 
 2224   
 2225          @param pObject : pointer to object 
 2226          @param y : flag (0|1) to disable/enable double buffer 
 2227      """ 
 2228   
 2229      _fl_set_object_dblbuffer = cfuncproto( 
 2230              load_so_libforms(), "fl_set_object_dblbuffer", \ 
 2231              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 2232              """void fl_set_object_dblbuffer(FL_OBJECT * ob, int y) 
 2233              """) 
 2234      iy = convert_to_int(y) 
 2235      keep_elem_refs(pObject, y, iy) 
 2236      _fl_set_object_dblbuffer(pObject, iy) 
 2237   
 2238   
 2239 -def fl_set_object_color(pObject, fgcolr, bgcolr): 
 2240      """ 
 2241          fl_set_object_color(pObject, fgcolr, bgcolr) 
 2242   
 2243          Sets the color of an object. 
 2244   
 2245          @param pObject : pointer to object 
 2246          @param fgcolr : foreground color 
 2247          @param bgcolr : background color 
 2248      """ 
 2249   
 2250      _fl_set_object_color = cfuncproto( 
 2251              load_so_libforms(), "fl_set_object_color", \ 
 2252              None, [cty.POINTER(FL_OBJECT), FL_COLOR, FL_COLOR], \ 
 2253              """void fl_set_object_color(FL_OBJECT * ob, FL_COLOR col1, 
 2254                 FL_COLOR col2) 
 2255              """) 
 2256      check_admitted_listvalues(fgcolr, COLOR_list) 
 2257      check_admitted_listvalues(bgcolr, COLOR_list) 
 2258      ulfgcolr = convert_to_FL_COLOR(fgcolr) 
 2259      ulbgcolr = convert_to_FL_COLOR(bgcolr) 
 2260      keep_elem_refs(pObject, fgcolr, ulfgcolr, bgcolr, ulbgcolr) 
 2261      _fl_set_object_color(pObject, ulfgcolr, ulbgcolr) 
 2262   
 2263   
 2264  #def fl_set_object_color(pObject, fgcolr, bgcolr)  *API change* 
 2265 -def fl_get_object_color(pObject): 
 2266      """ 
 2267          fl_set_object_color(pObject) -> fgcolr, bgcolr 
 2268   
 2269          Returns the foreground and background colors of an object. 
 2270   
 2271          @param pObject : pointer to object 
 2272      """ 
 2273   
 2274      _fl_get_object_color = cfuncproto( 
 2275              load_so_libforms(), "fl_get_object_color", \ 
 2276              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_COLOR), \ 
 2277              cty.POINTER(FL_COLOR)], \ 
 2278              """void fl_get_object_color(FL_OBJECT * ob, FL_COLOR * col1, 
 2279                 FL_COLOR * col2) 
 2280              """) 
 2281      fgcolr, pfgcolr = make_FL_COLOR_and_pointer() 
 2282      bgcolr, pbgcolr = make_FL_COLOR_and_pointer() 
 2283      keep_elem_refs(pObject, fgcolr, pfgcolr, bgcolr, pbgcolr) 
 2284      _fl_get_object_color(pObject, pfgcolr, pbgcolr) 
 2285      return fgcolr, bgcolr 
 2286   
 2287   
 2288 -def fl_set_object_label(pObject, label): 
 2289      """ 
 2290          fl_set_object_label(pObject, label) 
 2291   
 2292          Sets the label of an object. 
 2293   
 2294          @param pObject : pointer to object 
 2295          @param label : label of object 
 2296      """ 
 2297   
 2298      _fl_set_object_label = cfuncproto( 
 2299              load_so_libforms(), "fl_set_object_label", \ 
 2300              None, [cty.POINTER(FL_OBJECT), STRING], \ 
 2301              """void fl_set_object_label(FL_OBJECT * ob, const char * label) 
 2302              """) 
 2303      slabel = convert_to_string(label) 
 2304      keep_elem_refs(pObject, label, slabel) 
 2305      _fl_set_object_label(pObject, slabel) 
 2306   
 2307   
 2308 -def fl_get_object_label(pObject): 
 2309      """ 
 2310          fl_get_object_label(pObject) -> label 
 2311   
 2312          Returns the label of an object. 
 2313   
 2314          @param pObject : pointer to object 
 2315      """ 
 2316   
 2317      _fl_get_object_label = cfuncproto( 
 2318              load_so_libforms(), "fl_get_object_label", \ 
 2319              STRING, [cty.POINTER(FL_OBJECT)], \ 
 2320              """const char * fl_set_object_label(FL_OBJECT * obj) 
 2321              """) 
 2322      keep_elem_refs(pObject) 
 2323      retval = _fl_get_object_label(pObject) 
 2324      return retval 
 2325   
 2326   
 2327 -def fl_set_object_helper(pObject, tip): 
 2328      """ 
 2329          fl_set_object_helper(pObject, tip) 
 2330   
 2331          Sets the tooltip of an object. 
 2332   
 2333          @param pObject : pointer to object 
 2334          @param tip : tooltip text for object 
 2335      """ 
 2336   
 2337      _fl_set_object_helper = cfuncproto( 
 2338              load_so_libforms(), "fl_set_object_helper", \ 
 2339              None, [cty.POINTER(FL_OBJECT), STRING], \ 
 2340              """void fl_set_object_helper(FL_OBJECT * ob, const char * tip) 
 2341              """) 
 2342      stip = convert_to_string(tip) 
 2343      keep_elem_refs(pObject, tip, stip) 
 2344      _fl_set_object_helper(pObject, stip) 
 2345   
 2346   
 2347 -def fl_set_object_position(pObject, x, y): 
 2348      """ 
 2349          fl_set_object_position(pObject, x, y) 
 2350   
 2351          Sets position of an object. 
 2352   
 2353          @param pObject : pointer of object 
 2354          @param x : horizontal position 
 2355          @param y : vertical position 
 2356      """ 
 2357   
 2358      _fl_set_object_position = cfuncproto( 
 2359              load_so_libforms(), "fl_set_object_position", \ 
 2360              None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord], \ 
 2361              """void fl_set_object_position(FL_OBJECT * obj, FL_Coord x, 
 2362                 FL_Coord y) 
 2363              """) 
 2364      ix = convert_to_FL_Coord(x) 
 2365      iy = convert_to_FL_Coord(y) 
 2366      keep_elem_refs(pObject, x, ix, y, iy) 
 2367      _fl_set_object_position(pObject, ix, iy) 
 2368   
 2369   
 2370  #def fl_get_object_size(pObject, w, h)  *API change* 
 2371 -def fl_get_object_size(pObject): 
 2372      """ 
 2373          fl_get_object_size(pObject) -> width, height 
 2374   
 2375          Returns the size of an object. 
 2376   
 2377          @param pObject : pointer to object 
 2378      """ 
 2379   
 2380      _fl_get_object_size = cfuncproto( 
 2381              load_so_libforms(), "fl_get_object_size", \ 
 2382              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 
 2383              cty.POINTER(FL_Coord)], \ 
 2384              """void fl_get_object_size(FL_OBJECT * obj, FL_Coord * w, 
 2385                 FL_Coord * h) 
 2386              """) 
 2387      w, pw = make_FL_Coord_and_pointer() 
 2388      h, ph = make_FL_Coord_and_pointer() 
 2389      keep_elem_refs(pObject, w, h, pw, ph) 
 2390      _fl_get_object_size(pObject, pw, ph) 
 2391      return w, h 
 2392   
 2393   
 2394 -def fl_set_object_size(pObject, w, h): 
 2395      """ 
 2396          fl_set_object_size(pObject, w, h) 
 2397   
 2398          Sets the size of an object. 
 2399   
 2400          @param pObject : pointer to object 
 2401          @param w : width of object 
 2402          @param h : height of object 
 2403      """ 
 2404   
 2405      _fl_set_object_size = cfuncproto( 
 2406              load_so_libforms(), "fl_set_object_size", \ 
 2407              None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord], \ 
 2408              """void fl_set_object_size(FL_OBJECT * obj, FL_Coord w, 
 2409                 FL_Coord h) 
 2410              """) 
 2411      iw = convert_to_FL_Coord(w) 
 2412      ih = convert_to_FL_Coord(h) 
 2413      keep_elem_refs(pObject, w, iw, h, ih) 
 2414      _fl_set_object_size(pObject, iw, ih) 
 2415   
 2416   
 2417 -def fl_set_object_automatic(pObject, flag): 
 2418      """ 
 2419          fl_set_object_automatic(pObject, flag) 
 2420   
 2421          @param pObject : pointer to object 
 2422          @param flag : flag (0|1) 
 2423      """ 
 2424   
 2425      _fl_set_object_automatic = cfuncproto( 
 2426              load_so_libforms(), "fl_set_object_automatic", 
 2427              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 2428              """void fl_set_object_automatic(FL_OBJECT * ob, int flag) 
 2429              """) 
 2430      iflag = convert_to_int(flag) 
 2431      keep_elem_refs(pObject, flag, iflag) 
 2432      _fl_set_object_automatic(pObject, iflag) 
 2433   
 2434   
 2435 -def fl_object_is_automatic(pObject): 
 2436      """ 
 2437          fl_object_is_automatic(pObject) -> flag num. 
 2438   
 2439          @param pObject : pointer to object 
 2440      """ 
 2441   
 2442      _fl_object_is_automatic = cfuncproto( 
 2443              load_so_libforms(), "fl_object_is_automatic", 
 2444              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 2445              """int fl_object_is_automatic(FL_OBJECT * obj) 
 2446              """) 
 2447      keep_elem_refs(pObject) 
 2448      retval = _fl_object_is_automatic(pObject) 
 2449      return retval 
 2450   
 2451   
 2452 -def fl_draw_object_label(pObject): 
 2453      """ 
 2454          fl_draw_object_label(pObject) 
 2455   
 2456          @param pObject : pointer to object 
 2457      """ 
 2458   
 2459      _fl_draw_object_label = cfuncproto( 
 2460              load_so_libforms(), "fl_draw_object_label", \ 
 2461              None, [cty.POINTER(FL_OBJECT)], \ 
 2462              """void fl_draw_object_label(FL_OBJECT * ob) 
 2463              """) 
 2464      keep_elem_refs(pObject) 
 2465      _fl_draw_object_label(pObject) 
 2466   
 2467   
 2468 -def fl_draw_object_label_outside(pObject): 
 2469      """ 
 2470          fl_draw_object_label_outside(pObject) 
 2471   
 2472          @param pObject : pointer to object 
 2473      """ 
 2474   
 2475      _fl_draw_object_label_outside = cfuncproto( 
 2476              load_so_libforms(), "fl_draw_object_label_outside", 
 2477              None, [cty.POINTER(FL_OBJECT)], \ 
 2478              """void fl_draw_object_label_outside(FL_OBJECT * ob) 
 2479              """) 
 2480      keep_elem_refs(pObject) 
 2481      _fl_draw_object_label_outside(pObject) 
 2482   
 2483   
 2484 -def fl_get_object_component(pObjectComposite, objclass, compontype, numb): 
 2485      """ fl_get_object_component(pObjectComposite, objclass, compontype, numb) -> pObject 
 2486      """ 
 2487   
 2488      _fl_get_object_component = cfuncproto( 
 2489              load_so_libforms(), "fl_get_object_component", 
 2490              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT), cty.c_int, 
 2491              cty.c_int, cty.c_int], \ 
 2492              """FL_OBJECT * fl_get_object_component(FL_OBJECT * composite, 
 2493                 int objclass, int type, int numb) 
 2494              """) 
 2495      iobjclass = convert_to_int(objclass) 
 2496      icompontype = convert_to_int(compontype) 
 2497      inumb = convert_to_int(numb) 
 2498      keep_elem_refs(pObjectComposite, objclass, iobjclass, compontype, \ 
 2499                     icompontype, numb, inumb) 
 2500      retval = _fl_get_object_component(pObjectComposite, iobjclass, \ 
 2501                                        icompontype, inumb) 
 2502      return retval 
 2503   
 2504   
 2505  # cfunction for _fl_for_all_objects 
 2506  cfunc_int_pobject_pvoid = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), \ 
 2507                                          cty.c_void_p) 
 2508   
 2509 -def fl_for_all_objects(pForm, py_cb, v): 
 2510      """ 
 2511          fl_for_all_objects(pForm, py_cb, v) 
 2512   
 2513          @param pForm : pointer to form 
 2514          @param py_cb : python function, fn(pObject, ptr_void) -> num. 
 2515          @param v : argument 
 2516      """ 
 2517   
 2518      _fl_for_all_objects = cfuncproto( 
 2519              load_so_libforms(), "fl_for_all_objects", \ 
 2520              None, [cty.POINTER(FL_FORM), cfunc_int_pobject_pvoid, \ 
 2521              cty.c_void_p], \ 
 2522              """void fl_for_all_objects(FL_FORM * form, int ( * cb ) \ 
 2523                 ( FL_OBJECT *, void * ), void * v) 
 2524              """) 
 2525      c_cb = cfunc_int_pobject_pvoid(py_cb) 
 2526      pv = cty.cast(v, cty.c_void_p) 
 2527      keep_cfunc_refs(c_cb, py_cb) 
 2528      keep_elem_refs(pForm, v, pv) 
 2529      _fl_for_all_objects(pForm, c_cb, pv) 
 2530   
 2531   
 2532  fl_draw_object_outside_label = fl_draw_object_label_outside 
 2533   
 2534   
 2535 -def fl_set_object_dblclick(pObject, timeout): 
 2536      pObject.contents.click_timeout = timeout 
 2537   
 2538   
 2539 -def fl_set_object_geometry(pObject, x, y, w, h): 
 2540      """ 
 2541          fl_set_object_geometry(pObject, x, y, w, h) 
 2542   
 2543          Sets the geometry (position and size) of an object. 
 2544   
 2545          @param pObject : pointer to object 
 2546          @param x : horizontal position (upper-left corner) 
 2547          @param y : vertical position (upper-left corner) 
 2548          @param w : width of the object in pixels 
 2549          @param h : height of the object in pixels 
 2550      """ 
 2551   
 2552      _fl_set_object_geometry = cfuncproto( 
 2553              load_so_libforms(), "fl_set_object_geometry", \ 
 2554              None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord, FL_Coord, 
 2555              FL_Coord], \ 
 2556              """void fl_set_object_geometry(FL_OBJECT * obj, FL_Coord x, 
 2557              FL_Coord y, FL_Coord w, FL_Coord h) 
 2558              """) 
 2559      ix = convert_to_FL_Coord(x) 
 2560      iy = convert_to_FL_Coord(y) 
 2561      iw = convert_to_FL_Coord(w) 
 2562      ih = convert_to_FL_Coord(h) 
 2563      keep_elem_refs(pObject, x, ix, y, iy, w, iw, h, ih) 
 2564      _fl_set_object_geometry(pObject, ix, iy, iw, ih) 
 2565   
 2566   
 2567 -def fl_move_object(pObject, dx, dy): 
 2568      """ 
 2569          fl_move_object(pObject, dx, dy) 
 2570   
 2571          @param pObject : pointer to object 
 2572      """ 
 2573   
 2574      _fl_move_object = cfuncproto( 
 2575              load_so_libforms(), "fl_move_object", \ 
 2576              None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord], \ 
 2577              """void fl_move_object(FL_OBJECT * obj, FL_Coord dx, FL_Coord dy) 
 2578              """) 
 2579      idx = convert_to_int(dx) 
 2580      idy = convert_to_int(dy) 
 2581      keep_elem_refs(pObject, dx, idx, dy, idy) 
 2582      _fl_move_object(pObject, idx, idy) 
 2583   
 2584   
 2585  fl_set_object_lcolor = fl_set_object_lcol 
 2586   
 2587   
 2588 -def fl_fit_object_label(pObject, xmargin, ymargin): 
 2589      """ 
 2590          fl_fit_object_label(pObject, xmargin, ymargin) 
 2591   
 2592          Checks if the label of an object fits into it (after x- and 
 2593          y-margin have been added). If not, all objects and the form 
 2594          are enlarged by the necessary factor (but never by more than 
 2595          a factor of 1.5) 
 2596   
 2597          @param pObject : pointer to object 
 2598          @param xmargin : horizontal margin 
 2599          @param ymargin : vertical margin 
 2600      """ 
 2601   
 2602      _fl_fit_object_label = cfuncproto( 
 2603              load_so_libforms(), "fl_fit_object_label",\ 
 2604              None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord],\ 
 2605              """void fl_fit_object_label(FL_OBJECT * obj, FL_Coord xmargin, 
 2606                 FL_Coord ymargin) 
 2607              """) 
 2608      ixmargin = convert_to_int(xmargin) 
 2609      iymargin = convert_to_int(ymargin) 
 2610      keep_elem_refs(pObject, xmargin, ixmargin, ymargin, iymargin) 
 2611      _fl_fit_object_label(pObject, ixmargin, iymargin) 
 2612   
 2613   
 2614  #def fl_get_object_geometry(pObject, x, y, w, h)       *API change* 
 2615 -def fl_get_object_geometry(pObject): 
 2616      """ 
 2617          fl_get_object_geometry(pObject) -> hor-xpos, vert-ypos, width, height 
 2618   
 2619          Returns the geometry (position and size) of an object. 
 2620   
 2621          @param pObject : pointer to object 
 2622      """ 
 2623   
 2624      _fl_get_object_geometry = cfuncproto( 
 2625              load_so_libforms(), "fl_get_object_geometry",\ 
 2626          None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord),\ 
 2627          cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 
 2628          """void fl_get_object_geometry(FL_OBJECT * ob, FL_Coord * x, 
 2629             FL_Coord * y, FL_Coord * w, FL_Coord * h) 
 2630          """) 
 2631      x, px = make_FL_Coord_and_pointer() 
 2632      y, py = make_FL_Coord_and_pointer() 
 2633      w, pw = make_FL_Coord_and_pointer() 
 2634      h, ph = make_FL_Coord_and_pointer() 
 2635      keep_elem_refs(pObject, x, px, y, py, w, pw, h, ph) 
 2636      _fl_get_object_geometry(pObject, px, py, pw, ph) 
 2637      return x, y, w,h 
 2638   
 2639   
 2640  #def fl_get_object_position(pObject, x, y)       *API change* 
 2641 -def fl_get_object_position(pObject): 
 2642      """ 
 2643          fl_get_object_position(pObject) -> xpos, ypos 
 2644   
 2645          Returns the position of an object. 
 2646   
 2647          @param pObject : pointer to object 
 2648      """ 
 2649   
 2650      _fl_get_object_position = cfuncproto( 
 2651              load_so_libforms(), "fl_get_object_position",\ 
 2652              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 
 2653              cty.POINTER(FL_Coord)],\ 
 2654              """void fl_get_object_position(FL_OBJECT * ob, FL_Coord * x, 
 2655                 FL_Coord * y) 
 2656              """) 
 2657      x, px = make_FL_Coord_and_pointer() 
 2658      y, py = make_FL_Coord_and_pointer() 
 2659      keep_elem_refs(pObject, x, px, y, py) 
 2660      _fl_get_object_position(pObject, px, py) 
 2661      return x,y 
 2662   
 2663   
 2664  # this one takes into account the label 
 2665   
 2666  #def fl_get_object_bbox(pObject, x, y, w, h)       *API change* 
 2667 -def fl_get_object_bbox(pObject): 
 2668      """ 
 2669          fl_get_object_bbox(pObject) -> x, y, w, h 
 2670   
 2671          @param pObject : pointer to object 
 2672      """ 
 2673   
 2674      _fl_get_object_bbox = cfuncproto( 
 2675              load_so_libforms(), "fl_get_object_bbox",\ 
 2676              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord),\ 
 2677              cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 
 2678              cty.POINTER(FL_Coord)],\ 
 2679              """void fl_get_object_bbox(FL_OBJECT * obj, FL_Coord * x, 
 2680                 FL_Coord * y, FL_Coord * w, FL_Coord * h) 
 2681              """) 
 2682      x, px = make_FL_Coord_and_pointer() 
 2683      y, py = make_FL_Coord_and_pointer() 
 2684      w, pw = make_FL_Coord_and_pointer() 
 2685      h, ph = make_FL_Coord_and_pointer() 
 2686      keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 
 2687      _fl_get_object_bbox(pObject, px, py, pw, ph) 
 2688      return x, y, w,h 
 2689   
 2690   
 2691  fl_compute_object_geometry = fl_get_object_bbox 
 2692   
 2693   
 2694 -def fl_call_object_callback(pObject): 
 2695      """ 
 2696          fl_call_object_callback(pObject) 
 2697   
 2698          @param pObject : pointer to object 
 2699      """ 
 2700   
 2701      _fl_call_object_callback = cfuncproto( 
 2702              load_so_libforms(), "fl_call_object_callback",\ 
 2703              None, [cty.POINTER(FL_OBJECT)],\ 
 2704              """void fl_call_object_callback(FL_OBJECT * ob) 
 2705              """) 
 2706      keep_elem_refs(pObject) 
 2707      _fl_call_object_callback(pObject) 
 2708   
 2709   
 2710  #already defined in xfdata 
 2711  #FL_HANDLEPTR = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), cty.c_int, \ 
 2712  #                FL_Coord, FL_Coord, cty.c_int, cty.c_void_p) 
 2713   
 2714 -def fl_set_object_prehandler(pObject, py_HandlerPtr): 
 2715      """ 
 2716          fl_set_object_prehandler(pObject, py_HandlerPtr) ->  pHandlerPtr 
 2717   
 2718          @param pObject : pointer to object 
 2719          @param py_HandlerPtr : python callback function, fn(pObject, 
 2720             num, coord, coord, num, ptr_void) -> num 
 2721      """ 
 2722   
 2723      _fl_set_object_prehandler = cfuncproto( 
 2724              load_so_libforms(), "fl_set_object_prehandler", 
 2725              FL_HANDLEPTR, [cty.POINTER(FL_OBJECT), FL_HANDLEPTR],\ 
 2726              """FL_HANDLEPTR fl_set_object_prehandler(FL_OBJECT * ob, 
 2727                 FL_HANDLEPTR phandler) 
 2728              """) 
 2729      c_HandlerPtr = FL_HANDLEPTR(py_HandlerPtr) 
 2730      keep_cfunc_refs(c_HandlerPtr, py_HandlerPtr) 
 2731      keep_elem_refs(pObject) 
 2732      retval = _fl_set_object_prehandler(pObject, c_HandlerPtr) 
 2733      return retval 
 2734   
 2735   
 2736 -def fl_set_object_posthandler(pObject, py_HandlerPtr): 
 2737      """ 
 2738          fl_set_object_posthandler(pObject, py_HandlerPtr) -> pHandlerPtr 
 2739   
 2740          @param pObject : pointer to object 
 2741          @param py_HandlerPtr : python callback function, fn(pObject, 
 2742             num, coord, coord, num, ptr_void) -> num 
 2743      """ 
 2744   
 2745      _fl_set_object_posthandler = cfuncproto( 
 2746              load_so_libforms(), "fl_set_object_posthandler", 
 2747              FL_HANDLEPTR, [cty.POINTER(FL_OBJECT), FL_HANDLEPTR],\ 
 2748              """FL_HANDLEPTR fl_set_object_posthandler(FL_OBJECT * ob, 
 2749                 FL_HANDLEPTR post) 
 2750              """) 
 2751      c_HandlerPtr = FL_HANDLEPTR(py_HandlerPtr) 
 2752      keep_cfunc_refs(c_HandlerPtr, py_HandlerPtr) 
 2753      keep_elem_refs(pObject) 
 2754      retval = _fl_set_object_posthandler(pObject, c_HandlerPtr) 
 2755      return retval 
 2756   
 2757   
 2758  #already defined in xfdata 
 2759  #FL_CALLBACKPTR = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), cty.c_long) 
 2760   
 2761 -def fl_set_object_callback(pObject, py_CallbackPtr, argum): 
 2762      """ 
 2763          fl_set_object_callback(pObject, py_CallbackPtr, argum) -> c_callback func. 
 2764   
 2765          Calls a callback function bound to an object, if a condition is met. 
 2766   
 2767          @param pObject : pointer to object 
 2768          @param py_CallbackPtr : a python function with no () and no args to 
 2769             be used as callback, fn(pObject, longnum) 
 2770          @param argum : argument being passed to function 
 2771      """ 
 2772   
 2773      _fl_set_object_callback = cfuncproto( 
 2774              load_so_libforms(), "fl_set_object_callback",\ 
 2775              FL_CALLBACKPTR, [cty.POINTER(FL_OBJECT), FL_CALLBACKPTR, 
 2776              cty.c_long], 
 2777              """FL_CALLBACKPTR fl_set_object_callback(FL_OBJECT * obj,\ 
 2778              FL_CALLBACKPTR callback, long int argument) 
 2779              """) 
 2780      largum = convert_to_long(argum) 
 2781      c_CallbackPtr = FL_CALLBACKPTR(py_CallbackPtr) 
 2782      keep_cfunc_refs(c_CallbackPtr, py_CallbackPtr) 
 2783      keep_elem_refs(pObject, argum, largum) 
 2784      retval = _fl_set_object_callback(pObject, c_CallbackPtr, largum) 
 2785      return retval 
 2786   
 2787   
 2788  fl_set_object_align = fl_set_object_lalign 
 2789  fl_set_call_back = fl_set_object_callback 
 2790   
 2791   
 2792 -def fl_redraw_object(pObject): 
 2793      """ 
 2794          fl_redraw_object(pObject) 
 2795   
 2796          @param pObject : pointer to object 
 2797      """ 
 2798   
 2799      _fl_redraw_object = cfuncproto( 
 2800              load_so_libforms(), "fl_redraw_object",\ 
 2801              None, [cty.POINTER(FL_OBJECT)],\ 
 2802              """void fl_redraw_object(FL_OBJECT * obj) 
 2803              """) 
 2804      keep_elem_refs(pObject) 
 2805      _fl_redraw_object(pObject) 
 2806   
 2807   
 2808 -def fl_scale_object(pObject, xs, ys): 
 2809      """ 
 2810          fl_scale_object(pObject, xs, ys) 
 2811   
 2812          Scales (shrink or enlarge) an object. 
 2813   
 2814          @param pObject : pointer to object 
 2815          @param xs : new horizontal factor 
 2816          @param ys : new vertical factor 
 2817      """ 
 2818   
 2819      _fl_scale_object = cfuncproto( 
 2820              load_so_libforms(), "fl_scale_object",\ 
 2821              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double],\ 
 2822              """void fl_scale_object(FL_OBJECT * ob, double xs, double ys) 
 2823              """) 
 2824      fxs = convert_to_double(xs) 
 2825      fys = convert_to_double(ys) 
 2826      keep_elem_refs(pObject, xs, fxs, ys, fys) 
 2827      _fl_scale_object(pObject, fxs, fys) 
 2828   
 2829   
 2830 -def fl_show_object(pObject): 
 2831      """ 
 2832          fl_show_object(pObject) 
 2833   
 2834          @param pObject : pointer to object 
 2835      """ 
 2836   
 2837      _fl_show_object = cfuncproto( 
 2838              load_so_libforms(), "fl_show_object",\ 
 2839              None, [cty.POINTER(FL_OBJECT)],\ 
 2840              """void fl_show_object(FL_OBJECT * ob) 
 2841              """) 
 2842      keep_elem_refs(pObject) 
 2843      _fl_show_object(pObject) 
 2844      #pObject.contents.visible = 1 
 2845   
 2846   
 2847 -def fl_hide_object(pObject): 
 2848      """ 
 2849          fl_hide_object(pObject) 
 2850   
 2851          @param pObject : pointer to object 
 2852      """ 
 2853   
 2854      _fl_hide_object = cfuncproto( 
 2855              load_so_libforms(), "fl_hide_object",\ 
 2856              None, [cty.POINTER(FL_OBJECT)],\ 
 2857              """void fl_hide_object(FL_OBJECT * ob) 
 2858              """) 
 2859      keep_elem_refs(pObject) 
 2860      _fl_hide_object(pObject) 
 2861      #pObject.contents.visible = 0 
 2862   
 2863   
 2864 -def fl_object_is_visible(pObject): 
 2865      """ 
 2866          fl_object_is_visible(pObject) -> num. 
 2867   
 2868          @param pObject : pointer to object 
 2869      """ 
 2870   
 2871      _fl_object_is_visible = cfuncproto( 
 2872              load_so_libforms(), "fl_object_is_visible",\ 
 2873              cty.c_int, [cty.POINTER(FL_OBJECT)],\ 
 2874              """int fl_object_is_visible(FL_OBJECT * obj) 
 2875              """) 
 2876      keep_elem_refs(pObject) 
 2877      retval = _fl_object_is_visible(pObject) 
 2878      return retval 
 2879   
 2880   
 2881 -def fl_free_object(pObject): 
 2882      """ 
 2883          fl_free_object(pObject) 
 2884   
 2885          @param pObject : pointer to object 
 2886      """ 
 2887   
 2888      _fl_free_object = cfuncproto( 
 2889              load_so_libforms(), "fl_free_object",\ 
 2890              None, [cty.POINTER(FL_OBJECT)],\ 
 2891              """void fl_free_object(FL_OBJECT * obj) 
 2892              """) 
 2893      keep_elem_refs(pObject) 
 2894      _fl_free_object(pObject) 
 2895   
 2896   
 2897 -def fl_delete_object(pObject): 
 2898      """ 
 2899          fl_delete_object(pObject) 
 2900   
 2901          @param pObject : pointer to object 
 2902      """ 
 2903   
 2904      _fl_delete_object = cfuncproto( 
 2905              load_so_libforms(), "fl_delete_object",\ 
 2906              None, [cty.POINTER(FL_OBJECT)],\ 
 2907              """void fl_delete_object(FL_OBJECT * obj) 
 2908              """) 
 2909      keep_elem_refs(pObject) 
 2910      _fl_delete_object(pObject) 
 2911   
 2912   
 2913 -def fl_get_object_return_state(pObject): 
 2914      """ 
 2915          fl_get_object_return_state(pObject) -> ID num 
 2916   
 2917          @param pObject : pointer to object 
 2918      """ 
 2919   
 2920      _fl_get_object_return_state = cfuncproto( 
 2921              load_so_libforms(), "fl_get_object_return_state", 
 2922              cty.c_int, [cty.POINTER(FL_OBJECT)],\ 
 2923              """int fl_get_object_return_state(FL_OBJECT * obj) 
 2924              """) 
 2925      keep_elem_refs(pObject) 
 2926      retval = _fl_get_object_return_state(pObject) 
 2927      return retval 
 2928   
 2929   
 2930 -def fl_trigger_object(pObject): 
 2931      """ 
 2932          fl_trigger_object(pObject) 
 2933   
 2934          @param pObject : pointer to object 
 2935      """ 
 2936   
 2937      _fl_trigger_object = cfuncproto( 
 2938              load_so_libforms(), "fl_trigger_object",\ 
 2939              None, [cty.POINTER(FL_OBJECT)],\ 
 2940              """void fl_trigger_object(FL_OBJECT * obj) 
 2941              """) 
 2942      keep_elem_refs(pObject) 
 2943      _fl_trigger_object(pObject) 
 2944   
 2945   
 2946 -def fl_activate_object(pObject): 
 2947      """ 
 2948          fl_activate_object(pObject) 
 2949   
 2950          @param pObject : pointer to object 
 2951      """ 
 2952   
 2953      _fl_activate_object = cfuncproto( 
 2954              load_so_libforms(), "fl_activate_object",\ 
 2955              None, [cty.POINTER(FL_OBJECT)],\ 
 2956              """void fl_activate_object(FL_OBJECT * ob) 
 2957              """) 
 2958      keep_elem_refs(pObject) 
 2959      _fl_activate_object(pObject) 
 2960      #pObject.contents.active = 1 
 2961   
 2962   
 2963 -def fl_deactivate_object(pObject): 
 2964      """ 
 2965          fl_deactivate_object(pObject) 
 2966   
 2967          @param pObject : pointer to object 
 2968      """ 
 2969   
 2970      _fl_deactivate_object = cfuncproto( 
 2971              load_so_libforms(), "fl_deactivate_object",\ 
 2972              None, [cty.POINTER(FL_OBJECT)],\ 
 2973              """void fl_deactivate_object(FL_OBJECT * ob) 
 2974              """) 
 2975      keep_elem_refs(pObject) 
 2976      _fl_deactivate_object(pObject) 
 2977      #pObject.contents.active = 0 
 2978   
 2979   
 2980 -def fl_object_is_active(pObject): 
 2981      """ 
 2982          fl_object_is_active(pObject) -> num. 
 2983   
 2984          @param pObject : pointer to object 
 2985      """ 
 2986   
 2987      _fl_object_is_active = cfuncproto( 
 2988              load_so_libforms(), "fl_object_is_active",\ 
 2989              cty.c_int, [cty.POINTER(FL_OBJECT)],\ 
 2990              """int fl_object_is_active(FL_OBJECT * ob) 
 2991              """) 
 2992      keep_elem_refs(pObject) 
 2993      retval = _fl_object_is_active(pObject) 
 2994      return retval 
 2995   
 2996   
 2997  # cfunction for _fl_enumerate_fonts 
 2998  cfunc_none_string = cty.CFUNCTYPE(None, STRING) 
 2999   
 3000 -def fl_enumerate_fonts(py_output, shortform): 
 3001      """ fl_enumerate_fonts(py_output, shortform) -> ID num 
 3002      """ 
 3003   
 3004      _fl_enumerate_fonts = cfuncproto( 
 3005              load_so_libforms(), "fl_enumerate_fonts",\ 
 3006              cty.c_int, [cfunc_none_string, cty.c_int],\ 
 3007              """int fl_enumerate_fonts(void ( * output )( const char *s ), \ 
 3008                 int shortform) 
 3009              """) 
 3010      ishortform = convert_to_int(shortform) 
 3011      c_output = cfunc_none_string(py_output) 
 3012      keep_cfunc_refs(c_output, py_output) 
 3013      keep_elem_refs(shortform, ishortform) 
 3014      retval = _fl_enumerate_fonts(c_output, ishortform) 
 3015      return retval 
 3016   
 3017   
 3018 -def fl_set_font_name(n, name): 
 3019      """ fl_set_font_name(n, name) -> ID num 
 3020      """ 
 3021   
 3022      _fl_set_font_name = cfuncproto( 
 3023              load_so_libforms(), "fl_set_font_name",\ 
 3024              cty.c_int, [cty.c_int, STRING],\ 
 3025              """int fl_set_font_name(int n, const char * name) 
 3026              """) 
 3027      inum = convert_to_int(n) 
 3028      sname = convert_to_string(name) 
 3029      keep_elem_refs(n, inum, name, sname) 
 3030      retval = _fl_set_font_name(inum, sname) 
 3031      return retval 
 3032   
 3033   
 3034 -def fl_set_font(numb, size): 
 3035      """ fl_set_font(numb, size) 
 3036      """ 
 3037   
 3038      _fl_set_font = cfuncproto( 
 3039              load_so_libforms(), "fl_set_font",\ 
 3040              None, [cty.c_int, cty.c_int],\ 
 3041              """void fl_set_font(int numb, int size) 
 3042              """) 
 3043      inumb = convert_to_int(numb) 
 3044      isize = convert_to_int(size) 
 3045      keep_elem_refs(numb, inumb, size, isize) 
 3046      _fl_set_font(inumb, isize) 
 3047   
 3048   
 3049  # routines that facilitate free object 
 3050   
 3051  #def fl_get_char_height(style, size, asc, desc)       *API change* 
 3052 -def fl_get_char_height(style, size): 
 3053      """ fl_get_char_height(style, size) -> height num., asc, desc 
 3054      """ 
 3055   
 3056      _fl_get_char_height = cfuncproto( 
 3057              load_so_libforms(), "fl_get_char_height",\ 
 3058              cty.c_int, [cty.c_int, cty.c_int, cty.POINTER(cty.c_int), 
 3059              cty.POINTER(cty.c_int)],\ 
 3060              """int fl_get_char_height(int style, int size, int * asc, 
 3061                 int * desc) 
 3062              """) 
 3063      istyle = convert_to_int(style) 
 3064      isize = convert_to_int(size) 
 3065      asc, pasc = make_int_and_pointer()          # not sure 
 3066      desc, pdesc = make_int_and_pointer() 
 3067      keep_elem_refs(style, istyle, size, isize, asc, desc, pasc, pdesc) 
 3068      retval = _fl_get_char_height(istyle, isize, pasc, pdesc) 
 3069      return retval, asc, desc 
 3070   
 3071   
 3072 -def fl_get_char_width(style, size): 
 3073      """ fl_get_char_width(style, size) -> width num. 
 3074      """ 
 3075   
 3076      _fl_get_char_width = cfuncproto( 
 3077              load_so_libforms(), "fl_get_char_width",\ 
 3078              cty.c_int, [cty.c_int, cty.c_int],\ 
 3079              """int fl_get_char_width(int style, int size) 
 3080              """) 
 3081      istyle = convert_to_int(style) 
 3082      isize = convert_to_int(size) 
 3083      keep_elem_refs(style, istyle, size, isize) 
 3084      retval = _fl_get_char_width(istyle, isize) 
 3085      return retval 
 3086   
 3087   
 3088  #def fl_get_string_height(style, size, strng, strglen, asc, desc)       *API change* 
 3089 -def fl_get_string_height(style, size, strng, strglen): 
 3090      """ fl_get_string_height(style, size, strng, strglen) -> height num., asc, desc 
 3091      """ 
 3092   
 3093      _fl_get_string_height = cfuncproto( 
 3094              load_so_libforms(), "fl_get_string_height",\ 
 3095              cty.c_int, [cty.c_int, cty.c_int, STRING, cty.c_int, 
 3096              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\ 
 3097              """int fl_get_string_height(int style, int size, const char * s, 
 3098                 int len, int * asc, int * desc) 
 3099              """) 
 3100      istyle = convert_to_int(style) 
 3101      isize = convert_to_int(size) 
 3102      sstrng = convert_to_string(strng) 
 3103      istrglen = convert_to_int(strglen) 
 3104      #pasc = cty.cast(asc, cty.POINTER(cty.c_int)) 
 3105      asc, pasc = make_int_and_pointer() 
 3106      #pdesc = cty.cast(desc, cty.POINTER(cty.c_int)) 
 3107      desc, pdesc = make_int_and_pointer() 
 3108      keep_elem_refs(style, istyle, size, isize, strng, sstrng, strglen,\ 
 3109                     istrglen, asc, desc, pasc, pdesc) 
 3110      retval = _fl_get_string_height(istyle, isize, sstrng, istrglen,\ 
 3111                                     pasc, pdesc) 
 3112      return retval, asc, desc 
 3113   
 3114   
 3115 -def fl_get_string_width(style, size, s, strglen): 
 3116      """ fl_get_string_width(style, size, s, strglen) -> width num. 
 3117      """ 
 3118   
 3119      _fl_get_string_width = cfuncproto( 
 3120              load_so_libforms(), "fl_get_string_width",\ 
 3121              cty.c_int, [cty.c_int, cty.c_int, STRING, cty.c_int],\ 
 3122              """int fl_get_string_width(int style, int size, const char * s, 
 3123                 int len) 
 3124              """) 
 3125      istyle = convert_to_int(style) 
 3126      isize = convert_to_int(size) 
 3127      ss = convert_to_string(s) 
 3128      istrglen = convert_to_int(strglen) 
 3129      keep_elem_refs(style, istyle, size, isize, s, ss, strglen, istrglen) 
 3130      retval = _fl_get_string_width(istyle, isize, ss, istrglen) 
 3131      return retval 
 3132   
 3133   
 3134 -def fl_get_string_widthTAB(style, size, s, strglen): 
 3135      """ fl_get_string_widthTAB(style, size, s, strglen) -> width num. 
 3136      """ 
 3137   
 3138      _fl_get_string_widthTAB = cfuncproto( 
 3139              load_so_libforms(), "fl_get_string_widthTAB",\ 
 3140              cty.c_int, [cty.c_int, cty.c_int, STRING, cty.c_int],\ 
 3141              """int fl_get_string_widthTAB(int style, int size, const char * s, 
 3142                 int len) 
 3143              """) 
 3144      istyle = convert_to_int(style) 
 3145      isize = convert_to_int(size) 
 3146      ss = convert_to_string(s) 
 3147      istrglen = convert_to_int(strglen) 
 3148      keep_elem_refs(style, istyle, size, isize, s, ss, strglen, istrglen) 
 3149      retval = _fl_get_string_widthTAB(istyle, isize, ss, istrglen) 
 3150      return retval 
 3151   
 3152   
 3153  #def fl_get_string_dimension(fntstyle, fntsize, s, strglen, width, height)       *API change* 
 3154 -def fl_get_string_dimension(fntstyle, fntsize, s, strglen): 
 3155      """ fl_get_string_dimension(fntstyle, fntsize, s, strglen) -> width, height 
 3156      """ 
 3157   
 3158      _fl_get_string_dimension = cfuncproto( 
 3159              load_so_libforms(), "fl_get_string_dimension",\ 
 3160              None, [cty.c_int, cty.c_int, STRING, cty.c_int, 
 3161              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\ 
 3162              """void fl_get_string_dimension(int fntstyle, int fntsize, 
 3163                 const char * s, int len, int * width, int * height) 
 3164              """) 
 3165      ifntstyle = convert_to_int(fntstyle) 
 3166      ifntsize = convert_to_int(fntsize) 
 3167      ss = convert_to_string(s) 
 3168      istrglen = convert_to_int(strglen) 
 3169      width, pwidth = make_int_and_pointer() 
 3170      height, pheight = make_int_and_pointer() 
 3171      keep_elem_refs(fntstyle, ifntstyle, fntsize, ifntsize, s, ss, strglen, 
 3172                     istrglen, width, height, pwidth, pheight) 
 3173      _fl_get_string_dimension(ifntstyle, ifntsize, ss, istrglen, pwidth, 
 3174                              pheight) 
 3175      return width, height 
 3176   
 3177   
 3178  fl_get_string_size = fl_get_string_dimension 
 3179   
 3180   
 3181  #def fl_get_align_xy(align, x, y, w, h, xsize, ysize, xoff, yoff, xx, yy)       *API change* 
 3182 -def fl_get_align_xy(align, x, y, w, h, xsize, ysize, xoff, yoff): 
 3183      """ fl_get_align_xy(align, x, y, w, h, xsize, ysize, xoff, yoff) -> xx, yy 
 3184      """ 
 3185   
 3186      _fl_get_align_xy = cfuncproto( 
 3187              load_so_libforms(), "fl_get_align_xy",\ 
 3188              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int,\ 
 3189              cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.POINTER(cty.c_int),\ 
 3190              cty.POINTER(cty.c_int)],\ 
 3191              """void fl_get_align_xy(int align, int x, int y, int w, int h, 
 3192              int xsize, int ysize, int xoff, int yoff, int * xx, int * yy) 
 3193              """) 
 3194      check_admitted_listvalues(align, ALIGN_list) 
 3195      ialign = convert_to_int(align) 
 3196      ix = convert_to_int(x) 
 3197      iy = convert_to_int(y) 
 3198      iw = convert_to_int(w) 
 3199      ih = convert_to_int(h) 
 3200      ixsize = convert_to_int(xsize) 
 3201      iysize = convert_to_int(ysize) 
 3202      ixoff = convert_to_int(xoff) 
 3203      iyoff = convert_to_int(yoff) 
 3204      xx, pxx = make_int_and_pointer() 
 3205      yy, pyy = make_int_and_pointer() 
 3206      keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, xsize, ixsize, 
 3207                     ysize, iysize, xoff, ixoff, yoff, iyoff, xx, yy, pxx, pyy) 
 3208      _fl_get_align_xy(ialign, ix, iy, iw, ih, ixsize, iysize, ixoff, 
 3209                       iyoff, pxx, pyy) 
 3210      return xx, yy 
 3211   
 3212   
 3213 -def fl_drw_text(align, x, y, w, h, colr, style, size, txtstr): 
 3214      """ fl_drw_text(align, x, y, w, h, colr, style, size, txtstr) 
 3215      """ 
 3216   
 3217      _fl_drw_text = cfuncproto( 
 3218              load_so_libforms(), "fl_drw_text",\ 
 3219              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR, 
 3220              cty.c_int, cty.c_int, STRING],\ 
 3221              """void fl_drw_text(int align, FL_Coord x, FL_Coord y, FL_Coord w, 
 3222                 FL_Coord h, FL_COLOR c, int style, int size, const char * istr) 
 3223              """) 
 3224      check_admitted_listvalues(align, ALIGN_list) 
 3225      ialign = convert_to_int(align) 
 3226      ix = convert_to_FL_Coord(x) 
 3227      iy = convert_to_FL_Coord(y) 
 3228      iw = convert_to_FL_Coord(w) 
 3229      ih = convert_to_FL_Coord(h) 
 3230      ulcolr = convert_to_FL_COLOR(colr) 
 3231      istyle = convert_to_int(style) 
 3232      isize = convert_to_int(size) 
 3233      s_txtstr = convert_to_string(txtstr) 
 3234      keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, colr, 
 3235                     ulcolr, style, istyle, size, isize, txtstr, s_txtstr) 
 3236      _fl_drw_text(ialign, ix, iy, iw, ih, ulcolr, istyle, isize, 
 3237                   s_txtstr) 
 3238   
 3239   
 3240 -def fl_drw_text_beside(align, x, y, w, h, colr, style, size, txtstr): 
 3241      """ fl_drw_text_beside(align, x, y, w, h, colr, style, size, txtstr) 
 3242      """ 
 3243   
 3244      _fl_drw_text_beside = cfuncproto( 
 3245              load_so_libforms(), "fl_drw_text_beside",\ 
 3246              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR, 
 3247              cty.c_int, cty.c_int, STRING],\ 
 3248              """void fl_drw_text_beside(int align, FL_Coord x, FL_Coord y, 
 3249                 FL_Coord w, FL_Coord h, FL_COLOR c, int style, int size, 
 3250                 const char * str) 
 3251              """) 
 3252      check_admitted_listvalues(align, ALIGN_list) 
 3253      ialign = convert_to_int(align) 
 3254      ix = convert_to_FL_Coord(x) 
 3255      iy = convert_to_FL_Coord(y) 
 3256      iw = convert_to_FL_Coord(w) 
 3257      ih = convert_to_FL_Coord(h) 
 3258      ulcolr = convert_to_FL_COLOR(colr) 
 3259      istyle = convert_to_int(style) 
 3260      isize = convert_to_int(size) 
 3261      s_txtstr = convert_to_string(txtstr) 
 3262      keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, colr, 
 3263                     ulcolr, style, istyle, size, isize, txtstr, s_txtstr) 
 3264      _fl_drw_text_beside(ialign, ix, iy, iw, ih, ulcolr, istyle, 
 3265                          isize, s_txtstr) 
 3266   
 3267   
 3268 -def fl_drw_text_cursor(align, x, y, w, h, colr, style, size, txtstr, cc, pos): 
 3269      """ fl_drw_text_cursor(align, x, y, w, h, colr, style, size, txtstr, cc, pos) 
 3270      """ 
 3271   
 3272      _fl_drw_text_cursor = cfuncproto( 
 3273              load_so_libforms(), "fl_drw_text_cursor",\ 
 3274              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 
 3275              FL_COLOR, cty.c_int, cty.c_int, STRING, cty.c_int, cty.c_int],\ 
 3276              """void fl_drw_text_cursor(int align, FL_Coord x, FL_Coord y, 
 3277                 FL_Coord w, FL_Coord h, FL_COLOR c, int style, int size, 
 3278                 const char * str, int cc, int pos) 
 3279              """) 
 3280      check_admitted_listvalues(align, ALIGN_list) 
 3281      ialign = convert_to_int(align) 
 3282      ix = convert_to_FL_Coord(x) 
 3283      iy = convert_to_FL_Coord(y) 
 3284      iw = convert_to_FL_Coord(w) 
 3285      ih = convert_to_FL_Coord(h) 
 3286      ulcolr = convert_to_FL_COLOR(colr) 
 3287      istyle = convert_to_int(style) 
 3288      isize = convert_to_int(size) 
 3289      s_txtstr = convert_to_string(txtstr) 
 3290      icc = convert_to_int(cc) 
 3291      ipos = convert_to_int(pos) 
 3292      keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, colr, 
 3293                     ulcolr, style, istyle, size, isize, txtstr, s_txtstr, 
 3294                     cc, icc, pos, ipos) 
 3295      _fl_drw_text_cursor(ialign, ix, iy, iw, ih, ulcolr, istyle, 
 3296                          isize, s_txtstr, icc, ipos) 
 3297   
 3298   
 3299 -def fl_drw_box(style, x, y, w, h, colr, bwIn): 
 3300      """ fl_drw_box(style, x, y, w, h, colr, bwIn) 
 3301      """ 
 3302   
 3303      _fl_drw_box = cfuncproto( 
 3304              load_so_libforms(), "fl_drw_box",\ 
 3305              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR, 
 3306              cty.c_int],\ 
 3307              """void fl_drw_box(int style, FL_Coord x, FL_Coord y, FL_Coord w, 
 3308                 FL_Coord h, FL_COLOR c, int bw_in) 
 3309              """) 
 3310      istyle = convert_to_int(style) 
 3311      ix = convert_to_FL_Coord(x) 
 3312      iy = convert_to_FL_Coord(y) 
 3313      iw = convert_to_FL_Coord(w) 
 3314      ih = convert_to_FL_Coord(h) 
 3315      ulcolr = convert_to_FL_COLOR(colr) 
 3316      ibwIn = convert_to_int(bwIn) 
 3317      keep_elem_refs(style, istyle, x, ix, y, iy, w, iw, h, ih, colr, 
 3318                     ulcolr, bwIn, ibwIn) 
 3319      _fl_drw_box(style, x, y, w, h, ulcolr, ibwIn) 
 3320   
 3321   
 3322  FL_DRAWPTR = cty.CFUNCTYPE(None, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 
 3323                             cty.c_int, FL_COLOR) 
 3324   
 3325 -def fl_add_symbol(name, py_DrawPtr, scalable): 
 3326      """ 
 3327          fl_add_symbol(name, py_DrawPtr, scalable) -> num. 
 3328   
 3329          Adds a symbol. 
 3330   
 3331          @param name : name of a symbol 
 3332          @param py_DrawPtr : python function to draw symbol, fn(coord, coord, 
 3333             coord, coord, num, colr) 
 3334          @param scalable : not used 
 3335      """ 
 3336   
 3337      _fl_add_symbol = cfuncproto( 
 3338              load_so_libforms(), "fl_add_symbol",\ 
 3339              cty.c_int, [STRING, FL_DRAWPTR, cty.c_int],\ 
 3340              """int fl_add_symbol(const char * name, FL_DRAWPTR drawit, 
 3341                 int scalable) 
 3342              """) 
 3343      s_name = convert_to_string(name) 
 3344      iscalable = convert_to_int(scalable) 
 3345      c_DrawPtr = FL_DRAWPTR(py_DrawPtr) 
 3346      keep_cfunc_refs(c_DrawPtr, py_DrawPtr) 
 3347      keep_elem_refs(name, s_name, scalable, iscalable) 
 3348      retval = _fl_add_symbol(s_name, c_DrawPtr, iscalable) 
 3349      return retval 
 3350   
 3351   
 3352 -def fl_draw_symbol(label, x, y, w, h, colr): 
 3353      """ fl_draw_symbol(label, x, y, w, h, colr) -> num. 
 3354      """ 
 3355   
 3356      _fl_draw_symbol = cfuncproto( 
 3357              load_so_libforms(), "fl_draw_symbol",\ 
 3358              cty.c_int, [STRING, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 
 3359              FL_COLOR],\ 
 3360              """int fl_draw_symbol(const char * label, FL_Coord x, FL_Coord y, 
 3361                 FL_Coord w, FL_Coord h, FL_COLOR col) 
 3362              """) 
 3363      slabel = convert_to_string(label) 
 3364      ix = convert_to_FL_Coord(x) 
 3365      iy = convert_to_FL_Coord(y) 
 3366      iw = convert_to_FL_Coord(w) 
 3367      ih = convert_to_FL_Coord(h) 
 3368      ulcolr = convert_to_FL_COLOR(colr) 
 3369      keep_elem_refs(label, slabel, x, ix, y, iy, w, iw, h, ih, colr, 
 3370                     ulcolr) 
 3371      retval = _fl_draw_symbol(slabel, ix, iy, iw, ih, ulcolr) 
 3372      return retval 
 3373   
 3374   
 3375 -def fl_mapcolor(colr, r, g, b): 
 3376      """ fl_mapcolor(colr, r, g, b) -> num. 
 3377      """ 
 3378   
 3379      _fl_mapcolor = cfuncproto( 
 3380              load_so_libforms(), "fl_mapcolor",\ 
 3381              cty.c_ulong, [FL_COLOR, cty.c_int, cty.c_int, cty.c_int],\ 
 3382              """long unsigned int fl_mapcolor(FL_COLOR col, int r, int g, int b) 
 3383              """) 
 3384      ulcolr = convert_to_FL_COLOR(colr) 
 3385      ir = convert_to_int(r) 
 3386      ig = convert_to_int(g) 
 3387      ib = convert_to_int(b) 
 3388      keep_elem_refs(colr, ulcolr, r, ir, g, ig, b, ib) 
 3389      retval = _fl_mapcolor(ulcolr, ir, ig, ib) 
 3390      return retval 
 3391   
 3392   
 3393 -def fl_mapcolorname(colr, name): 
 3394      """ fl_mapcolorname(colr, name) -> num. 
 3395      """ 
 3396   
 3397      _fl_mapcolorname = cfuncproto( 
 3398              load_so_libforms(), "fl_mapcolorname",\ 
 3399              cty.c_long, [FL_COLOR, STRING],\ 
 3400              """long int fl_mapcolorname(FL_COLOR col, const char * name) 
 3401              """) 
 3402      ulcolr = convert_to_FL_COLOR(colr) 
 3403      sname = convert_to_string(name) 
 3404      keep_elem_refs(colr, ulcolr, name, sname) 
 3405      retval = _fl_mapcolorname(ulcolr, sname) 
 3406      return retval 
 3407   
 3408   
 3409  fl_mapcolor_name = fl_mapcolorname 
 3410   
 3411   
 3412 -def fl_free_colors(c, n): 
 3413      """ fl_free_colors(c, n) 
 3414      """ 
 3415   
 3416      _fl_free_colors = cfuncproto( 
 3417              load_so_libforms(), "fl_free_colors",\ 
 3418              None, [cty.POINTER(FL_COLOR), cty.c_int],\ 
 3419              """void fl_free_colors(FL_COLOR * c, int n) 
 3420              """) 
 3421      inum = convert_to_int(n) 
 3422      keep_elem_refs(c, n, inum) 
 3423      _fl_free_colors(c, inum) 
 3424   
 3425   
 3426 -def fl_free_pixels(pix, n): 
 3427      """ fl_free_pixels(pix, n) 
 3428      """ 
 3429   
 3430      _fl_free_pixels = cfuncproto( 
 3431              load_so_libforms(), "fl_free_pixels",\ 
 3432              None, [cty.POINTER(cty.c_ulong), cty.c_int],\ 
 3433              """void fl_free_pixels(long unsigned int * pix, int n) 
 3434              """) 
 3435      inum = convert_to_int(n) 
 3436      keep_elem_refs(pix, n, inum) 
 3437      _fl_free_pixels(pix, inum) 
 3438   
 3439   
 3440 -def fl_set_color_leak(y): 
 3441      """ fl_set_color_leak(y) 
 3442      """ 
 3443   
 3444      _fl_set_color_leak = cfuncproto( 
 3445              load_so_libforms(), "fl_set_color_leak",\ 
 3446              None, [cty.c_int],\ 
 3447              """void fl_set_color_leak(int y) 
 3448              """) 
 3449      iy = convert_to_int(y) 
 3450      keep_elem_refs(y, iy) 
 3451      _fl_set_color_leak(iy) 
 3452   
 3453   
 3454  #def fl_getmcolor(colr, r, g, b)       *API change* 
 3455 -def fl_getmcolor(colr): 
 3456      """ fl_getmcolor(colr) -> num., r, g,b 
 3457      """ 
 3458   
 3459      _fl_getmcolor = cfuncproto( 
 3460              load_so_libforms(), "fl_getmcolor",\ 
 3461              cty.c_ulong, [FL_COLOR, cty.POINTER(cty.c_int),\ 
 3462              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\ 
 3463              """long unsigned int fl_getmcolor(FL_COLOR i, int * r, int * g, 
 3464                 int * b) 
 3465              """) 
 3466      check_admitted_listvalues(colr, COLOR_list) 
 3467      ulcolr = convert_to_FL_COLOR(colr) 
 3468      r, pr = make_int_and_pointer() 
 3469      g, pg = make_int_and_pointer() 
 3470      b, pb = make_int_and_pointer() 
 3471      keep_elem_refs(colr, ulcolr, r, g, b, pr, pg, pb) 
 3472      retval = _fl_getmcolor(ulcolr, pr, pg, pb) 
 3473      return retval, r, g,b 
 3474   
 3475   
 3476 -def fl_get_pixel(colr): 
 3477      """ fl_get_pixel(colr) -> pixel num. 
 3478      """ 
 3479   
 3480      _fl_get_pixel = cfuncproto( 
 3481              load_so_libforms(), "fl_get_pixel",\ 
 3482              cty.c_ulong, [FL_COLOR],\ 
 3483              """long unsigned int fl_get_pixel(FL_COLOR col) 
 3484              """) 
 3485      check_admitted_listvalues(colr, COLOR_list) 
 3486      ulcolr = convert_to_FL_COLOR(colr) 
 3487      keep_elem_refs(colr, ulcolr) 
 3488      retval = _fl_get_pixel(ulcolr) 
 3489      return retval 
 3490   
 3491   
 3492  fl_get_flcolor = fl_get_pixel 
 3493   
 3494   
 3495  #def fl_get_icm_color(colr, r, g, b)       *API change* 
 3496 -def fl_get_icm_color(colr): 
 3497      """ fl_get_icm_color(colr) -> r, g,b 
 3498      """ 
 3499   
 3500      _fl_get_icm_color = cfuncproto( 
 3501              load_so_libforms(), "fl_get_icm_color",\ 
 3502              None, [FL_COLOR, cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
 3503              cty.POINTER(cty.c_int)],\ 
 3504              """void fl_get_icm_color(FL_COLOR col, int * r, int * g, int * b) 
 3505              """) 
 3506      check_admitted_listvalues(colr, COLOR_list) 
 3507      ulcolr = convert_to_FL_COLOR(colr) 
 3508      r, pr = make_int_and_pointer() 
 3509      g, pg = make_int_and_pointer() 
 3510      b, pb = make_int_and_pointer() 
 3511      keep_elem_refs(colr, ulcolr, r, g, b, pr, pg, pb) 
 3512      _fl_get_icm_color(ulcolr, pr, pg, pb) 
 3513      return r, g,b 
 3514   
 3515   
 3516 -def fl_set_icm_color(colr, r, g, b): 
 3517      """ fl_set_icm_color(colr, r, g, b) 
 3518      """ 
 3519   
 3520      _fl_set_icm_color = cfuncproto( 
 3521              load_so_libforms(), "fl_set_icm_color",\ 
 3522              None, [FL_COLOR, cty.c_int, cty.c_int, cty.c_int],\ 
 3523              """void fl_set_icm_color(FL_COLOR col, int r, int g, int b) 
 3524              """) 
 3525      ulcolr = convert_to_FL_COLOR(colr) 
 3526      ir = convert_to_int(r) 
 3527      ig = convert_to_int(g) 
 3528      ib = convert_to_int(b) 
 3529      keep_elem_refs(colr, ulcolr, r, g, b, ir, ig, ib) 
 3530      _fl_set_icm_color(ulcolr, ir, ig, ib) 
 3531   
 3532   
 3533 -def fl_color(colr): 
 3534      """ fl_color(colr) 
 3535      """ 
 3536   
 3537      _fl_color = cfuncproto( 
 3538              load_so_libforms(), "fl_color",\ 
 3539              None, [FL_COLOR],\ 
 3540              """void fl_color(FL_COLOR col) 
 3541              """) 
 3542      check_admitted_listvalues(colr, COLOR_list) 
 3543      ulcolr = convert_to_FL_COLOR(colr) 
 3544      keep_elem_refs(colr, ulcolr) 
 3545      _fl_color(ulcolr) 
 3546   
 3547   
 3548 -def fl_bk_color(colr): 
 3549      """ fl_bk_color(colr) 
 3550      """ 
 3551   
 3552      _fl_bk_color = cfuncproto( 
 3553              load_so_libforms(), "fl_bk_color",\ 
 3554              None, [FL_COLOR],\ 
 3555              """void fl_bk_color(FL_COLOR col) 
 3556              """) 
 3557      check_admitted_listvalues(colr, COLOR_list) 
 3558      ulcolr = convert_to_FL_COLOR(colr) 
 3559      keep_elem_refs(colr, ulcolr) 
 3560      _fl_bk_color(ulcolr) 
 3561   
 3562   
 3563 -def fl_textcolor(colr): 
 3564      """ fl_textcolor(colr) 
 3565      """ 
 3566   
 3567      _fl_textcolor = cfuncproto( 
 3568              load_so_libforms(), "fl_textcolor",\ 
 3569              None, [FL_COLOR],\ 
 3570              """void fl_textcolor(FL_COLOR col) 
 3571              """) 
 3572      check_admitted_listvalues(colr, COLOR_list) 
 3573      ulcolr = convert_to_FL_COLOR(colr) 
 3574      keep_elem_refs(colr, ulcolr) 
 3575      _fl_textcolor(ulcolr) 
 3576   
 3577   
 3578 -def fl_bk_textcolor(colr): 
 3579      """ fl_bk_textcolor(colr) 
 3580      """ 
 3581   
 3582      _fl_bk_textcolor = cfuncproto( 
 3583              load_so_libforms(), "fl_bk_textcolor",\ 
 3584              None, [FL_COLOR],\ 
 3585              """void fl_bk_textcolor(FL_COLOR col) 
 3586              """) 
 3587      check_admitted_listvalues(colr, COLOR_list) 
 3588      ulcolr = convert_to_FL_COLOR(colr) 
 3589      keep_elem_refs(colr, ulcolr) 
 3590      _fl_bk_textcolor(ulcolr) 
 3591   
 3592   
 3593 -def fl_set_gamma(r, g, b): 
 3594      """ 
 3595          fl_set_gamma(r, g, b) 
 3596   
 3597          @param r : value for red 
 3598          @param g : value for green 
 3599          @param b : value for blue 
 3600      """ 
 3601   
 3602      _fl_set_gamma = cfuncproto( 
 3603              load_so_libforms(), "fl_set_gamma",\ 
 3604              None, [cty.c_double, cty.c_double, cty.c_double],\ 
 3605              """void fl_set_gamma(double r, double g, double b) 
 3606              """) 
 3607      fr = convert_to_double(r) 
 3608      fg = convert_to_double(g) 
 3609      fb = convert_to_double(b) 
 3610      keep_elem_refs(r, fr, g, fg, b, fb) 
 3611      _fl_set_gamma(fr, fg, fb) 
 3612   
 3613   
 3614 -def fl_show_errors(y): 
 3615      """ fl_show_errors(y) 
 3616      """ 
 3617   
 3618      _fl_show_errors = cfuncproto( 
 3619              load_so_libforms(), "fl_show_errors",\ 
 3620              None, [cty.c_int],\ 
 3621              """void fl_show_errors(int y) 
 3622              """) 
 3623      iy = convert_to_int(y) 
 3624      keep_elem_refs(y, iy) 
 3625      _fl_show_errors(iy) 
 3626   
 3627   
 3628  # Some macros 
 3629   
 3630 -def FL_max(a, b): 
 3631      if (a > b): 
 3632          return a 
 3633      else: 
 3634          return b 
 3635   
 3636 -def FL_min(a, b): 
 3637      if (a < b): 
 3638          return a 
 3639      else: 
 3640          return b 
 3641   
 3642 -def FL_abs(a): 
 3643      if (a > 0): 
 3644          return a 
 3645      else: 
 3646          return (-a) 
 3647   
 3648 -def FL_nint(a): 
 3649      if int(a) > 0: 
 3650          return (a + 0.5) 
 3651      else: 
 3652          return (a - 0.5) 
 3653   
 3654 -def FL_clamp(a, amin, amax): 
 3655      if (a < amin): 
 3656          return amin 
 3657      elif (a > amax): 
 3658          return amax 
 3659      else: 
 3660          return a 
 3661   
 3662 -def FL_crnd(a): 
 3663      if FL_Coord(a) > 0: 
 3664          return (a + 0.5) 
 3665      else: 
 3666          return (a - 0.5) 
 3667   
 3668   
 3669  # utilities for new objects 
 3670   
 3671 -def fl_add_object(pForm, pObject): 
 3672      """ 
 3673          fl_add_object(pForm, pObject) 
 3674   
 3675          @param pForm : pointer to form 
 3676          @param pObject : pointer to object 
 3677      """ 
 3678   
 3679      _fl_add_object = cfuncproto( 
 3680              load_so_libforms(), "fl_add_object",\ 
 3681              None, [cty.POINTER(FL_FORM), cty.POINTER(FL_OBJECT)],\ 
 3682              """void fl_add_object(FL_FORM * form, FL_OBJECT * obj) 
 3683              """) 
 3684      keep_elem_refs(pForm, pObject) 
 3685      _fl_add_object(pForm, pObject) 
 3686   
 3687   
 3688 -def fl_addto_form(pForm): 
 3689      """ 
 3690          fl_addto_form(pForm) -> pForm 
 3691   
 3692          Reopens a form for input. 
 3693   
 3694          @param pForm : pointer to form 
 3695      """ 
 3696   
 3697      _fl_addto_form = cfuncproto( 
 3698              load_so_libforms(), "fl_addto_form", 
 3699              cty.POINTER(FL_FORM), [cty.POINTER(FL_FORM)],\ 
 3700              """FL_FORM * fl_addto_form(FL_FORM * form) 
 3701              """) 
 3702      keep_elem_refs(pForm) 
 3703      retval = _fl_addto_form(pForm) 
 3704      return retval 
 3705   
 3706   
 3707 -def fl_make_object(objclass, objtype, x, y, w, h, label, py_HandlePtr): 
 3708      """ 
 3709          fl_make_object(objclass, objtype, x, y, w, h, label, py_HandlePtr) -> pObject 
 3710      """ 
 3711   
 3712      _fl_make_object = cfuncproto( 
 3713              load_so_libforms(), "fl_make_object",\ 
 3714              cty.POINTER(FL_OBJECT), [cty.c_int, cty.c_int, FL_Coord,\ 
 3715              FL_Coord, FL_Coord, FL_Coord, STRING, FL_HANDLEPTR],\ 
 3716              """FL_OBJECT * fl_make_object(int objclass, int type, FL_Coord x, 
 3717                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label, 
 3718                 FL_HANDLEPTR handle) 
 3719              """) 
 3720      iobjclass = convert_to_int(objclass) 
 3721      iobjtype = convert_to_int(objtype) 
 3722      ix = convert_to_FL_Coord(x) 
 3723      iy = convert_to_FL_Coord(y) 
 3724      iw = convert_to_FL_Coord(w) 
 3725      ih = convert_to_FL_Coord(h) 
 3726      slabel = convert_to_string(label) 
 3727      c_HandlePtr = FL_HANDLEPTR(py_HandlePtr) 
 3728      keep_cfunc_refs(c_HandlePtr, py_HandlePtr) 
 3729      keep_elem_refs(objclass, objtype, x, y, w, h, label, iobjclass, 
 3730                     iobjtype, ix, iy, iw, ih, slabel) 
 3731      retval = _fl_make_object(iobjclass, iobjtype, ix, iy, iw, 
 3732                               ih, slabel, c_HandlePtr) 
 3733      return retval 
 3734   
 3735   
 3736 -def fl_add_child(pObject1, pObject2): 
 3737      """ 
 3738          fl_add_child(pObject1, pObject2) 
 3739   
 3740          @param pObject1 : pointer to father object 
 3741          @param pObject2 : pointer to child object 
 3742      """ 
 3743   
 3744      _fl_add_child = cfuncproto( 
 3745              load_so_libforms(), "fl_add_child",\ 
 3746              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_OBJECT)],\ 
 3747              """void fl_add_child(FL_OBJECT * p1, FL_OBJECT * p2) 
 3748              """) 
 3749      keep_elem_refs(pObject1, pObject2) 
 3750      _fl_add_child(pObject1, pObject2) 
 3751   
 3752   
 3753 -def fl_set_coordunit(u): 
 3754      """ 
 3755          fl_set_coordunit(u) 
 3756   
 3757          @param u :? 
 3758      """ 
 3759   
 3760      _fl_set_coordunit = cfuncproto( 
 3761              load_so_libforms(), "fl_set_coordunit",\ 
 3762              None, [cty.c_int],\ 
 3763              """void fl_set_coordunit(int u) 
 3764              """) 
 3765      iu = convert_to_int(u) 
 3766      keep_elem_refs(u, iu) 
 3767      _fl_set_coordunit(iu) 
 3768   
 3769   
 3770 -def fl_set_border_width(bw): 
 3771      """ 
 3772          fl_set_border_width(bw) 
 3773   
 3774          Sets the width of the border. 
 3775   
 3776          @param bw : width of border 
 3777      """ 
 3778   
 3779      _fl_set_border_width = cfuncproto( 
 3780              load_so_libforms(), "fl_set_border_width",\ 
 3781              None, [cty.c_int],\ 
 3782              """void fl_set_border_width(int bw) 
 3783              """) 
 3784      ibw = convert_to_int(bw) 
 3785      keep_elem_refs(bw, ibw) 
 3786      _fl_set_border_width(ibw) 
 3787   
 3788   
 3789 -def fl_set_scrollbar_type(sbtype): 
 3790      """ 
 3791          fl_set_scrollbar_type(sbtype) 
 3792   
 3793          @param sbtype : type of scrollbar 
 3794      """ 
 3795   
 3796      _fl_set_scrollbar_type = cfuncproto( 
 3797              load_so_libforms(), "fl_set_scrollbar_type",\ 
 3798              None, [cty.c_int],\ 
 3799              """void fl_set_scrollbar_type(int t) 
 3800              """) 
 3801      check_admitted_listvalues(sbtype, SCROLLTYPE_list) 
 3802      isbtype = convert_to_int(sbtype) 
 3803      keep_elem_refs(sbtype, isbtype) 
 3804      _fl_set_scrollbar_type(isbtype) 
 3805   
 3806   
 3807 -def fl_set_thinscrollbar(t): 
 3808      if t: 
 3809          t_type = FL_THIN_SCROLLBAR 
 3810      else: 
 3811          t_type = FL_NORMAL_SCROLLBAR 
 3812      fl_set_scrollbar_type(t_type) 
 3813   
 3814   
 3815 -def fl_flip_yorigin(): 
 3816      """ fl_flip_yorigin() 
 3817      """ 
 3818   
 3819      _fl_flip_yorigin = cfuncproto( 
 3820              load_so_libforms(), "fl_flip_yorigin",\ 
 3821              None, [],\ 
 3822              """void fl_flip_yorigin() 
 3823              """) 
 3824      _fl_flip_yorigin() 
 3825   
 3826   
 3827 -def fl_get_coordunit(): 
 3828      """ fl_get_coordunit() -> coord_unit num. 
 3829      """ 
 3830   
 3831      _fl_get_coordunit = cfuncproto( 
 3832              load_so_libforms(), "fl_get_coordunit",\ 
 3833              cty.c_int, [],\ 
 3834              """int fl_get_coordunit() 
 3835              """) 
 3836      retval = _fl_get_coordunit() 
 3837      return retval 
 3838   
 3839   
 3840 -def fl_get_border_width(): 
 3841      """ fl_get_border_width() -> width num. 
 3842      """ 
 3843   
 3844      _fl_get_border_width = cfuncproto( 
 3845              load_so_libforms(), "fl_get_border_width",\ 
 3846              cty.c_int, [],\ 
 3847              """int fl_get_border_width() 
 3848              """) 
 3849      retval = _fl_get_border_width() 
 3850      return retval 
 3851   
 3852   
 3853  # misc. routines 
 3854   
 3855 -def fl_ringbell(percent): 
 3856      """ 
 3857          fl_ringbell(percent) 
 3858   
 3859          Sounds the keyboard ringbell (if capable). 
 3860   
 3861          @param percent : volume value for the bell, min -100 (off), max  100, 
 3862             0 is default 
 3863      """ 
 3864   
 3865      _fl_ringbell = cfuncproto( 
 3866              load_so_libforms(), "fl_ringbell",\ 
 3867              None, [cty.c_int],\ 
 3868              """void fl_ringbell(int percent) 
 3869              """) 
 3870      ipercent = convert_to_int(percent) 
 3871      keep_elem_refs(percent, ipercent) 
 3872      _fl_ringbell(ipercent) 
 3873   
 3874   
 3875  #def fl_gettime(sec, usec)       *API change* 
 3876 -def fl_gettime(): 
 3877      """ 
 3878          fl_gettime() -> sec, usec 
 3879   
 3880          Returns the current time, expressed in seconds and microseconds 
 3881          since 00:00 GMT January, 1970. It is most useful for computing 
 3882          time differences 
 3883      """ 
 3884   
 3885      _fl_gettime = cfuncproto( 
 3886              load_so_libforms(), "fl_gettime",\ 
 3887              None, [cty.POINTER(cty.c_long), cty.POINTER(cty.c_long)],\ 
 3888              """void fl_gettime(long int * sec, long int * usec) 
 3889              """) 
 3890      sec, psec = make_long_and_pointer() 
 3891      usec, pusec = make_long_and_pointer() 
 3892      keep_elem_refs(sec, usec, psec, pusec) 
 3893      _fl_gettime(psec, pusec) 
 3894      return sec, usec 
 3895   
 3896   
 3897 -def fl_now(): 
 3898      """ 
 3899          fl_now() -> string 
 3900   
 3901          Returns a string form of the current date and time. The format of 
 3902          the string is of the form "Wed Jun 30 21:49:08 1993" 
 3903      """ 
 3904   
 3905      _fl_now = cfuncproto( 
 3906              load_so_libforms(), "fl_now",\ 
 3907              STRING, [],\ 
 3908              """const char * fl_now() 
 3909              """) 
 3910      retval = _fl_now() 
 3911      return retval 
 3912   
 3913   
 3914 -def fl_whoami(): 
 3915      """ 
 3916          fl_whoami() -> string 
 3917   
 3918          Returns the user name who is running the application. 
 3919      """ 
 3920   
 3921      _fl_whoami = cfuncproto( 
 3922              load_so_libforms(), "fl_whoami",\ 
 3923              STRING, [],\ 
 3924              """const char * fl_whoami() 
 3925              """) 
 3926      retval = _fl_whoami() 
 3927      return retval 
 3928   
 3929   
 3930 -def fl_mouse_button(): 
 3931      """ fl_mouse_button() -> num. 
 3932      """ 
 3933   
 3934      _fl_mouse_button = cfuncproto( 
 3935              load_so_libforms(), "fl_mouse_button",\ 
 3936              cty.c_long, [],\ 
 3937              """long int fl_mouse_button() 
 3938              """) 
 3939      retval = _fl_mouse_button() 
 3940      return retval 
 3941   
 3942  fl_mousebutton = fl_mouse_button 
 3943   
 3944   
 3945   
 3946 -def fl_strdup(strng): 
 3947      """ fl_strdup(strng) -> string 
 3948      """ 
 3949   
 3950      _fl_strdup = cfuncproto( 
 3951              load_so_libforms(), "fl_strdup",\ 
 3952              STRING, [STRING],\ 
 3953              """char * fl_strdup(const char * s) 
 3954              """) 
 3955      sstrng = convert_to_string(strng) 
 3956      keep_elem_refs(strng, sstrng) 
 3957      retval = _fl_strdup(sstrng) 
 3958      return retval 
 3959   
 3960   
 3961 -def fl_set_err_logfp(pFile): 
 3962      """ fl_set_err_logfp(pFile) 
 3963      """ 
 3964   
 3965      _fl_set_err_logfp = cfuncproto( 
 3966              load_so_libforms(), "fl_set_err_logfp",\ 
 3967              None, [cty.POINTER(FILE)],\ 
 3968              """void fl_set_err_logfp(FILE * fp) 
 3969              """) 
 3970      keep_elem_refs(pFile) 
 3971      _fl_set_err_logfp(pFile) 
 3972   
 3973  # This function was called 'fl_set_error_logfp/' in XForms 0.89. 
 3974  fl_set_error_logfp = fl_set_err_logfp 
 3975   
 3976   
 3977   
 3978 -def fl_set_error_handler(py_ErrorFunc): 
 3979      """ 
 3980          fl_set_error_handler(py_ErrorFunc) 
 3981      """ 
 3982   
 3983      _fl_set_error_handler = cfuncproto( 
 3984              load_so_libforms(), "fl_set_error_handler",\ 
 3985              None, [FL_ERROR_FUNC],\ 
 3986              """void fl_set_error_handler(FL_ERROR_FUNC user_func) 
 3987              """) 
 3988      c_ErrorFunc = FL_ERROR_FUNC(py_ErrorFunc) 
 3989      keep_cfunc_refs(c_ErrorFunc, py_ErrorFunc) 
 3990      retval = _fl_set_error_handler(c_ErrorFunc) 
 3991      return retval 
 3992   
 3993   
 3994 -def fl_get_cmdline_args(p1): 
 3995      """ fl_get_cmdline_args(p1) -> string 
 3996      """ 
 3997   
 3998      _fl_get_cmdline_args = cfuncproto( 
 3999              load_so_libforms(), "fl_get_cmdline_args",\ 
 4000              cty.POINTER(STRING), [cty.POINTER(cty.c_int)],\ 
 4001              """)char * * fl_get_cmdline_args(int * p1) 
 4002              """) 
 4003      keep_elem_refs(p1) 
 4004      retval = _fl_get_cmdline_args(p1) 
 4005      return retval 
 4006   
 4007   
 4008  # these give more flexibility for future changes. Also application 
 4009  # can re-assign these pointers to whatever function it wants, e.g., 
 4010  # to a shared memory pool allocator. 
 4011   
 4012  #fl_free = (cty.CFUNCTYPE(None, cty.c_void_p)).in_dll(load_so_libforms(), 'fl_free') 
 4013 -def fl_free(p1): 
 4014      """ fl_free(p1) 
 4015      """ 
 4016   
 4017      _fl_free = cfuncproto( 
 4018              load_so_libforms(), "fl_free",\ 
 4019              None, [cty.c_void_p], 
 4020              """void ( * fl_free )( void *) 
 4021              """) 
 4022      keep_elem_refs(p1) 
 4023      _fl_free(p1) 
 4024   
 4025   
 4026  # cfunction for _fl_malloc 
 4027  cfunc_none_sizet = cty.CFUNCTYPE(cty.c_void_p, size_t) 
 4028   
 4029  # low-level function maybe unused in python 
 4030  ##fl_malloc = (cty.CFUNCTYPE(cty.c_void_p, size_t)).in_dll(load_so_libforms(), 
 4031  #             'fl_malloc') 
 4032  #def fl_malloc(size): 
 4033  #    """ fl_malloc(size) -> pointer 
 4034  #    """# 
 4035  #   _fl_malloc = cfuncproto( 
 4036  #           load_so_libforms(), "fl_malloc",\ 
 4037  #           cty.c_void_p, [size_t], 
 4038  #           """void * ( * fl_malloc )( size_t) 
 4039  #           """) 
 4040  #    uisize = convert_to_uint(size) 
 4041  #    keep_elem_refs(size, uisize) 
 4042  #    retval = _fl_malloc(uisize) 
 4043  #    return retval 
 4044   
 4045   
 4046  # cfunction for _fl_calloc 
 4047  cfunc_none_sizet_sizet = cty.CFUNCTYPE(cty.c_void_p, size_t, size_t) 
 4048   
 4049  # low-level function maybe unused in python 
 4050  ##fl_calloc = (cty.CFUNCTYPE(cty.c_void_p, size_t, size_t)).in_dll(\ 
 4051  #             load_so_libforms(), 'fl_calloc') 
 4052  #def fl_calloc(size): 
 4053  #    """ fl_calloc(size) -> pointer 
 4054  #    """# 
 4055  #   _fl_calloc = cfuncproto( 
 4056  #        load_so_libforms(), "fl_malloc",\ 
 4057  #        cty.c_void_p, [size_t, size_t], 
 4058  #        """void * ( * fl_calloc )( size_t) 
 4059  #        """) 
 4060  #    uisize = convert_to_uint(size) 
 4061  #    keep_elem_refs(size, uisize) 
 4062  #    retval = _fl_calloc(uisize) 
 4063  #    return retval 
 4064   
 4065   
 4066  # cfunction for _fl_realloc 
 4067  cfunc_voidp_voidp_sizet = cty.CFUNCTYPE(cty.c_void_p, cty.c_void_p, size_t) 
 4068   
 4069  # low-level function maybe unused in python 
 4070  ##fl_realloc = (cty.CFUNCTYPE(cty.c_void_p, cty.c_void_p, size_t)).in_dll(\ 
 4071  #               load_so_libforms(), 'fl_realloc') 
 4072  #def fl_realloc(py_p1, size): 
 4073  #    """ fl_realloc(py_p1, size) -> pointer 
 4074  #    """# 
 4075  #    _fl_realloc = cfuncproto( 
 4076  #        load_so_libforms(), "fl_realloc",\ 
 4077  #        cty.c_void_p, [cty.c_void_p, size_t], 
 4078  #        """void * ( * fl_realloc )( void* 
 4079  #        """) 
 4080  #    uisize = convert_to_uint(size) 
 4081  #    c_p1 = cfunc_voidp_voidp_sizet(py_p1) 
 4082  #    keep_cfunc_refs(c_p1) 
 4083  #    keep_elem_refs(size, uisize) 
 4084  #    retval = _fl_realloc(c_p1, uisize) 
 4085  #    return retval 
 4086   
 4087   
 4088 -def fl_msleep(msec): 
 4089      """ 
 4090          fl_msleep(msec) -> num. 
 4091   
 4092          Waits for a number of milliseconds (with the best resolution 
 4093          possible on your system) 
 4094   
 4095          @param msec : milliseconds to sleep 
 4096      """ 
 4097   
 4098      _fl_msleep = cfuncproto( 
 4099              load_so_libforms(), "fl_msleep",\ 
 4100              cty.c_int, [cty.c_ulong],\ 
 4101              """int fl_msleep(long unsigned int msec) 
 4102              """) 
 4103      ulmsec = convert_to_ulong(msec) 
 4104      keep_elem_refs(msec, ulmsec) 
 4105      retval = _fl_msleep(ulmsec) 
 4106      return retval 
 4107   
 4108   
 4109 -def fl_is_same_object(pObject1, pObject2): 
 4110      """ 
 4111          fl_is_same_object(pObject1, pObject2) -> num. 
 4112   
 4113          Does a comparison between two objects. 
 4114      """ 
 4115   
 4116      _fl_is_same_object = cfuncproto( 
 4117              load_so_libforms(), "fl_is_same_object", \ 
 4118              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_OBJECT)], \ 
 4119              """int fl_is_same_object(FL_OBJECT * obj1, FL_OBJECT * obj2) 
 4120              """) 
 4121      keep_elem_refs(pObject1, pObject2) 
 4122      retval = _fl_is_same_object(pObject1, pObject2) 
 4123      return retval 
 4124   
 4125   
 4126   
 4127  ################### 
 4128  # XBasic.h 
 4129  ################## 
 4130   
 4131 -def FL_is_gray(v): 
 4132      if (v == GrayScale) or (v == StaticGray): 
 4133          return True 
 4134      else: 
 4135          return False 
 4136   
 4137   
 4138 -def FL_is_rgb(v): 
 4139      if (v == TrueColor) or (v == DirectColor): 
 4140          return True 
 4141      else: 
 4142          return False 
 4143   
 4144   
 4145  # Current version only runs in single visual mode 
 4146 -def fl_get_vclass(): 
 4147      return fl_vmode 
 4148   
 4149   
 4150 -def fl_get_form_vclass(a): 
 4151      return fl_vmode 
 4152   
 4153   
 4154 -def fl_get_gc(): 
 4155      return fl_state[fl_vmode].gc[0] 
 4156   
 4157   
 4158 -def fl_mode_capable(mode, warn): 
 4159      """ 
 4160          fl_mode_capable(mode, warn) -> mode num. 
 4161   
 4162          Determines the visual classes the system is capable of. It returns 
 4163          1 if the system is capable of displaying in this visual class and 
 4164          0 otherwise. 
 4165   
 4166          @param mode : visual mode (i.e. xfc.FL_GrayScale, xfc.FL_StaticGray, 
 4167             xfc.FL_PseudoColor, xfc.FL_StaticColor, xfc.FL_DirectColor and 
 4168             xfc.FL_TrueColor) 
 4169          @param warn : warning (0|1), if set a warning is printed out in case 
 4170             the capability asked for isn't available 
 4171      """ 
 4172   
 4173      _fl_mode_capable = cfuncproto( 
 4174              load_so_libforms(), "fl_mode_capable",\ 
 4175              cty.c_int, [cty.c_int, cty.c_int],\ 
 4176              """int fl_mode_capable(int mode, int warn) 
 4177              """) 
 4178      imode = convert_to_int(mode) 
 4179      iwarn = convert_to_int(warn) 
 4180      keep_elem_refs(mode, warn, imode, iwarn) 
 4181      retval = _fl_mode_capable(imode, iwarn) 
 4182      return retval 
 4183   
 4184   
 4185 -def fl_default_win(): 
 4186      return fl_state[fl_vmode].trailblazer 
 4187   
 4188   
 4189 -def fl_default_window(): 
 4190      return fl_state[fl_vmode].trailblazer 
 4191   
 4192   
 4193  # Some basic drawing routines 
 4194   
 4195  # Rectangles 
 4196   
 4197 -def fl_rectangle(fill, x, y, w, h, colr): 
 4198      """ fl_rectangle(fill, x, y, w, h, colr) 
 4199      """ 
 4200   
 4201      _fl_rectangle = cfuncproto( 
 4202              load_so_libforms(), "fl_rectangle",\ 
 4203              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 
 4204              FL_COLOR],\ 
 4205              """void fl_rectangle(int fill, FL_Coord x, FL_Coord y, 
 4206                 FL_Coord w, FL_Coord h, FL_COLOR col) 
 4207              """) 
 4208      check_admitted_listvalues(colr, COLOR_list) 
 4209      ifill = convert_to_int(fill) 
 4210      ix = convert_to_FL_Coord(x) 
 4211      iy = convert_to_FL_Coord(y) 
 4212      iw = convert_to_FL_Coord(w) 
 4213      ih = convert_to_FL_Coord(h) 
 4214      ulcolr = convert_to_FL_COLOR(colr) 
 4215      keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, 
 4216                     ulcolr) 
 4217      _fl_rectangle(ifill, ix, iy, iw, ih, ulcolr) 
 4218   
 4219   
 4220 -def fl_rectbound(x, y, w, h, colr): 
 4221      """ fl_rectbound(x, y, w, h, colr) 
 4222      """ 
 4223   
 4224      _fl_rectbound = cfuncproto( 
 4225              load_so_libforms(), "fl_rectbound",\ 
 4226              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR],\ 
 4227              """void fl_rectbound(FL_Coord x, FL_Coord y, FL_Coord w, 
 4228                 FL_Coord h, FL_COLOR col) 
 4229              """) 
 4230      check_admitted_listvalues(colr, COLOR_list) 
 4231      ix = convert_to_FL_Coord(x) 
 4232      iy = convert_to_FL_Coord(y) 
 4233      iw = convert_to_FL_Coord(w) 
 4234      ih = convert_to_FL_Coord(h) 
 4235      ulcolr = convert_to_FL_COLOR(colr) 
 4236      keep_elem_refs(x, y, w, h, colr, ix, iy, iw, ih, ulcolr) 
 4237      _fl_rectbound(ix, iy, iw, ih, ulcolr) 
 4238   
 4239   
 4240 -def fl_rectf(x, y, w, h, colr): 
 4241      fl_rectangle(1, x, y, w, h, colr) 
 4242   
 4243   
 4244 -def fl_rect(x, y, w, h, colr): 
 4245      fl_rectangle(0, x, y, w, h, colr) 
 4246   
 4247   
 4248  # Rectangle with rounded-corners 
 4249   
 4250 -def fl_roundrectangle(fill, x, y, w, h, colr): 
 4251      """ fl_roundrectangle(fill, x, y, w, h, colr) 
 4252      """ 
 4253   
 4254      _fl_roundrectangle = cfuncproto( 
 4255              load_so_libforms(), "fl_roundrectangle",\ 
 4256              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 
 4257              FL_COLOR],\ 
 4258              """void fl_roundrectangle(int fill, FL_Coord x, FL_Coord y, 
 4259                 FL_Coord w, FL_Coord h, FL_COLOR col) 
 4260              """) 
 4261      check_admitted_listvalues(colr, COLOR_list) 
 4262      ifill = convert_to_int(fill) 
 4263      ix = convert_to_FL_Coord(x) 
 4264      iy = convert_to_FL_Coord(y) 
 4265      iw = convert_to_FL_Coord(w) 
 4266      ih = convert_to_FL_Coord(h) 
 4267      ulcolr = convert_to_FL_COLOR(colr) 
 4268      keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, 
 4269                     ulcolr) 
 4270      _fl_roundrectangle(ifill, ix, iy, iw, ih, ulcolr) 
 4271   
 4272   
 4273 -def fl_roundrectf(x, y, w, h, colr): 
 4274      fl_roundrectangle(1, x, y, w, h, colr) 
 4275   
 4276   
 4277 -def fl_roundrect(x, y, w, h, colr): 
 4278      fl_roundrectangle(0, x, y, w, h, colr) 
 4279   
 4280   
 4281  # General polygon and polylines 
 4282   
 4283 -def fl_polygon(fill, pPoint, n, colr): 
 4284      """ fl_polygon(fill, pPoint, n, colr) 
 4285      """ 
 4286   
 4287      _fl_polygon = cfuncproto( 
 4288              load_so_libforms(), "fl_polygon",\ 
 4289              None, [cty.c_int, cty.POINTER(FL_POINT), cty.c_int, FL_COLOR],\ 
 4290              """void fl_polygon(int fill, FL_POINT * xp, int n, FL_COLOR col) 
 4291              """) 
 4292      check_admitted_listvalues(colr, COLOR_list) 
 4293      ifill = convert_to_int(fill) 
 4294      inum = convert_to_int(n) 
 4295      ulcolr = convert_to_FL_COLOR(colr) 
 4296      keep_elem_refs(fill, pPoint, n, colr, ifill, inum, ulcolr) 
 4297      _fl_polygon(ifill, pPoint, inum, ulcolr) 
 4298   
 4299   
 4300 -def fl_polyf(pPoint, n, colr): 
 4301      fl_polygon(1, pPoint, n, colr) 
 4302   
 4303   
 4304 -def fl_polyl(pPoint, n, colr): 
 4305      fl_polygon(0, pPoint, n, colr) 
 4306   
 4307 -def fl_polybound(pPoint, n, colr): 
 4308      fl_polygon(1, pPoint, n, colr) 
 4309      fl_polygon(0, pPoint, n, FL_BLACK) 
 4310   
 4311   
 4312 -def fl_lines(pPoint, n, colr): 
 4313      """ fl_lines(pPoint, n, colr) 
 4314      """ 
 4315   
 4316      _fl_lines = cfuncproto( 
 4317              load_so_libforms(), "fl_lines",\ 
 4318              None, [cty.POINTER(FL_POINT), cty.c_int, FL_COLOR],\ 
 4319              """void fl_lines(FL_POINT * xp, int n, FL_COLOR col) 
 4320              """) 
 4321      check_admitted_listvalues(colr, COLOR_list) 
 4322      inum = convert_to_int(n) 
 4323      ulcolr = convert_to_FL_COLOR(colr) 
 4324      keep_elem_refs(pPoint, n, colr, inum, ulcolr) 
 4325      _fl_lines(pPoint, inum, ulcolr) 
 4326   
 4327   
 4328 -def fl_line(xi, yi, xf, yf, colr): 
 4329      """ fl_line(xi, yi, xf, yf, colr) 
 4330      """ 
 4331   
 4332      _fl_line = cfuncproto( 
 4333              load_so_libforms(), "fl_line",\ 
 4334              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR],\ 
 4335              """void fl_line(FL_Coord xi, FL_Coord yi, FL_Coord xf, 
 4336                 FL_Coord yf, FL_COLOR c) 
 4337              """) 
 4338      check_admitted_listvalues(colr, COLOR_list) 
 4339      ixi = convert_to_int(xi) 
 4340      iyi = convert_to_int(yi) 
 4341      ixf = convert_to_int(xf) 
 4342      iyf = convert_to_int(yf) 
 4343      ulcolr = convert_to_FL_COLOR(colr) 
 4344      keep_elem_refs(xi, yi, xf, yf, colr, ixi, iyi, ixf, iyf, ulcolr) 
 4345      _fl_line(ixi, iyi, ixf, iyf, ulcolr) 
 4346   
 4347   
 4348 -def fl_point(x, y, colr): 
 4349      """ fl_point(x, y, colr) 
 4350      """ 
 4351   
 4352      _fl_point = cfuncproto( 
 4353              load_so_libforms(), "fl_point",\ 
 4354              None, [FL_Coord, FL_Coord, FL_COLOR],\ 
 4355              """void fl_point(FL_Coord x, FL_Coord y, FL_COLOR c) 
 4356              """) 
 4357      check_admitted_listvalues(colr, COLOR_list) 
 4358      ix = convert_to_FL_Coord(x) 
 4359      iy = convert_to_FL_Coord(y) 
 4360      ulcolr = convert_to_FL_COLOR(colr) 
 4361      keep_elem_refs(x, y, colr, ix, iy, ulcolr) 
 4362      _fl_point(ix, iy, ulcolr) 
 4363   
 4364   
 4365 -def fl_points(pPoint, np, colr): 
 4366      """ fl_points(pPoint, np, colr) 
 4367      """ 
 4368   
 4369      _fl_points = cfuncproto( 
 4370              load_so_libforms(), "fl_points",\ 
 4371              None, [cty.POINTER(FL_POINT), cty.c_int, FL_COLOR],\ 
 4372              """void fl_points(FL_POINT * p, int np, FL_COLOR c) 
 4373              """) 
 4374      check_admitted_listvalues(colr, COLOR_list) 
 4375      inump = convert_to_int(np) 
 4376      ulcolr = convert_to_FL_COLOR(colr) 
 4377      keep_elem_refs(pPoint, np, colr, inump, ulcolr) 
 4378      _fl_points(pPoint, inump, ulcolr) 
 4379   
 4380   
 4381  fl_simple_line = fl_line 
 4382   
 4383   
 4384 -def fl_dashedlinestyle(dash, ndash): 
 4385      """ fl_dashedlinestyle(dash, ndash) 
 4386      """ 
 4387   
 4388      _fl_dashedlinestyle = cfuncproto( 
 4389              load_so_libforms(), "fl_dashedlinestyle",\ 
 4390              None, [STRING, cty.c_int],\ 
 4391              """void fl_dashedlinestyle(const char * dash, int ndash) 
 4392              """) 
 4393      sdash = convert_to_string(dash) 
 4394      indash = convert_to_int(ndash) 
 4395      keep_elem_refs(dash, ndash, sdash, indash) 
 4396      _fl_dashedlinestyle(sdash, indash) 
 4397   
 4398   
 4399 -def fl_update_display(block): 
 4400      """ fl_update_display(block) 
 4401      """ 
 4402   
 4403      _fl_update_display = cfuncproto( 
 4404              load_so_libforms(), "fl_update_display",\ 
 4405              None, [cty.c_int],\ 
 4406              """void fl_update_display(int block) 
 4407              """) 
 4408      iblock = convert_to_int(block) 
 4409      keep_elem_refs(block, iblock) 
 4410      _fl_update_display(iblock) 
 4411   
 4412   
 4413 -def fl_diagline(x, y, w, h, colr): 
 4414      fl_line(x, y, (x) + (w) - 1, (y) + (h) - 1, colr) 
 4415   
 4416   
 4417  # Line attributes 
 4418   
 4419 -def fl_linewidth(n): 
 4420      """ fl_linewidth(n) 
 4421      """ 
 4422   
 4423      _fl_linewidth = cfuncproto( 
 4424              load_so_libforms(), "fl_linewidth",\ 
 4425              None, [cty.c_int],\ 
 4426              """void fl_linewidth(int n) 
 4427              """) 
 4428      inum = convert_to_int(n) 
 4429      keep_elem_refs(n, inum) 
 4430      _fl_linewidth(inum) 
 4431   
 4432   
 4433 -def fl_linestyle(n): 
 4434      """ fl_linestyle(n) 
 4435      """ 
 4436   
 4437      _fl_linestyle = cfuncproto( 
 4438              load_so_libforms(), "fl_linestyle",\ 
 4439              None, [cty.c_int],\ 
 4440              """void fl_linestyle(int n) 
 4441              """) 
 4442      inum = convert_to_int(n) 
 4443      keep_elem_refs(n, inum) 
 4444      _fl_linestyle(inum) 
 4445   
 4446   
 4447 -def fl_drawmode(request): 
 4448      """ fl_drawmode(request) 
 4449      """ 
 4450   
 4451      _fl_drawmode = cfuncproto( 
 4452              load_so_libforms(), "fl_drawmode",\ 
 4453              None, [cty.c_int],\ 
 4454              """void fl_drawmode(int request) 
 4455              """) 
 4456      irequest = convert_to_int(request) 
 4457      keep_elem_refs(request, irequest) 
 4458      _fl_drawmode(irequest) 
 4459   
 4460   
 4461 -def fl_get_linewidth(): 
 4462      """ fl_get_linewidth() -> width num. 
 4463      """ 
 4464   
 4465      _fl_get_linewidth = cfuncproto( 
 4466              load_so_libforms(), "fl_get_linewidth",\ 
 4467              cty.c_int, [],\ 
 4468              """int fl_get_linewidth() 
 4469              """) 
 4470      retval = _fl_get_linewidth() 
 4471      return retval 
 4472   
 4473   
 4474 -def fl_get_linestyle(): 
 4475      """ fl_get_linestyle() -> style num. 
 4476      """ 
 4477   
 4478      _fl_get_linestyle = cfuncproto( 
 4479              load_so_libforms(), "fl_get_linestyle",\ 
 4480              cty.c_int, [],\ 
 4481              """int fl_get_linestyle() 
 4482              """) 
 4483      retval = _fl_get_linestyle() 
 4484      return retval 
 4485   
 4486   
 4487 -def fl_get_drawmode(): 
 4488      """ fl_get_drawmode() -> mode num. 
 4489      """ 
 4490   
 4491      _fl_get_drawmode = cfuncproto( 
 4492              load_so_libforms(), "fl_get_drawmode",\ 
 4493              cty.c_int, [],\ 
 4494              """int fl_get_drawmode() 
 4495              """) 
 4496      retval = _fl_get_drawmode() 
 4497      return retval 
 4498   
 4499   
 4500  fl_set_linewidth = fl_linewidth 
 4501  fl_set_linestyle = fl_linestyle 
 4502  fl_set_drawmode = fl_drawmode 
 4503   
 4504   
 4505  # Ellipses 
 4506   
 4507 -def fl_oval(fill, x, y, w, h, colr): 
 4508      """ fl_oval(fill, x, y, w, h, colr) 
 4509      """ 
 4510   
 4511      _fl_oval = cfuncproto( 
 4512              load_so_libforms(), "fl_oval",\ 
 4513              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 
 4514              FL_COLOR],\ 
 4515              """void fl_oval(int fill, FL_Coord x, FL_Coord y, FL_Coord w, 
 4516                 FL_Coord h, FL_COLOR col) 
 4517              """) 
 4518      check_admitted_listvalues(colr, COLOR_list) 
 4519      ifill = convert_to_int(fill) 
 4520      ix = convert_to_FL_Coord(x) 
 4521      iy = convert_to_FL_Coord(y) 
 4522      iw = convert_to_FL_Coord(w) 
 4523      ih = convert_to_FL_Coord(h) 
 4524      ulcolr = convert_to_FL_COLOR(colr) 
 4525      keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, 
 4526                     ulcolr) 
 4527      _fl_oval(ifill, ix, iy, iw, ih, ulcolr) 
 4528   
 4529   
 4530 -def fl_ovalbound(x, y, w, h, colr): 
 4531      """ fl_ovalbound(x, y, w, h, colr) 
 4532      """ 
 4533   
 4534      _fl_ovalbound = cfuncproto( 
 4535              load_so_libforms(), "fl_ovalbound",\ 
 4536              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR],\ 
 4537              """void fl_ovalbound(FL_Coord x, FL_Coord y, FL_Coord w, 
 4538                 FL_Coord h, FL_COLOR col) 
 4539              """) 
 4540      check_admitted_listvalues(colr, COLOR_list) 
 4541      ix = convert_to_FL_Coord(x) 
 4542      iy = convert_to_FL_Coord(y) 
 4543      iw = convert_to_FL_Coord(w) 
 4544      ih = convert_to_FL_Coord(h) 
 4545      ulcolr = convert_to_FL_COLOR(colr) 
 4546      keep_elem_refs(x, y, w, h, colr, ix, iy, iw, ih, ulcolr) 
 4547      _fl_ovalbound(ix, iy, iw, ih, ulcolr) 
 4548   
 4549   
 4550 -def fl_ovalarc(fill, x, y, w, h, t0, dt, colr): 
 4551      """ fl_ovalarc(fill, x, y, w, h, t0, dt, colr) 
 4552      """ 
 4553   
 4554      _fl_ovalarc = cfuncproto( 
 4555              load_so_libforms(), "fl_ovalarc",\ 
 4556              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 
 4557              cty.c_int, cty.c_int, FL_COLOR],\ 
 4558              """void fl_ovalarc(int fill, FL_Coord x, FL_Coord y, FL_Coord w, 
 4559                 FL_Coord h, int t0, int dt, FL_COLOR col) 
 4560              """) 
 4561      check_admitted_listvalues(colr, COLOR_list) 
 4562      ifill = convert_to_int(fill) 
 4563      ix = convert_to_FL_Coord(x) 
 4564      iy = convert_to_FL_Coord(y) 
 4565      iw = convert_to_FL_Coord(w) 
 4566      ih = convert_to_FL_Coord(h) 
 4567      it0 = convert_to_int(t0) 
 4568      idt = convert_to_int(dt) 
 4569      ulcolr = convert_to_FL_COLOR(colr) 
 4570      keep_elem_refs(fill, x, y, w, h, t0, dt, colr, ifill, ix, iy, iw, 
 4571                     ih, it0, idt, ulcolr) 
 4572      _fl_ovalarc(ifill, ix, iy, iw, ih, it0, idt, ulcolr) 
 4573   
 4574   
 4575 -def fl_ovalf(x, y, w, h, colr): 
 4576      fl_oval(1, x, y, w, h, colr) 
 4577   
 4578   
 4579 -def fl_ovall(x, y, w, h, colr): 
 4580      fl_oval(0, x, y, w, h, colr) 
 4581   
 4582   
 4583  fl_oval_bound = fl_ovalbound 
 4584   
 4585   
 4586 -def fl_circf(x, y, r, colr): 
 4587      fl_oval(1, (x) - (r), (y) - (r), 2 * (r), 2 * (r), colr) 
 4588   
 4589   
 4590 -def fl_circ( x, y, r, colr): 
 4591      fl_oval(0, (x) - (r), (y) - (r), 2 * (r), 2 * (r), colr) 
 4592   
 4593   
 4594  # Arcs 
 4595   
 4596 -def fl_pieslice(fill, x, y, w, h, a1, a2, colr): 
 4597      """ fl_pieslice(fill, x, y, w, h, a1, a2, colr) 
 4598      """ 
 4599   
 4600      _fl_pieslice = cfuncproto( 
 4601              load_so_libforms(), "fl_pieslice",\ 
 4602              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 
 4603              cty.c_int, cty.c_int, FL_COLOR],\ 
 4604              """void fl_pieslice(int fill, FL_Coord x, FL_Coord y, FL_Coord w, 
 4605                 FL_Coord h, int a1, int a2, FL_COLOR col) 
 4606              """) 
 4607      check_admitted_listvalues(colr, COLOR_list) 
 4608      ifill = convert_to_int(fill) 
 4609      ix = convert_to_FL_Coord(x) 
 4610      iy = convert_to_FL_Coord(y) 
 4611      iw = convert_to_FL_Coord(w) 
 4612      ih = convert_to_FL_Coord(h) 
 4613      ia1 = convert_to_int(a1) 
 4614      ia2 = convert_to_int(a2) 
 4615      ulcolr = convert_to_FL_COLOR(colr) 
 4616      keep_elem_refs(fill, x, y, w, h, a1, a2, colr, ifill, ix, iy, iw, 
 4617                     ih, ia1, ia2, ulcolr) 
 4618      _fl_pieslice(ifill, ix, iy, iw, ih, ia1, ia2, ulcolr) 
 4619   
 4620   
 4621 -def fl_arcf(x, y, r, a1, a2, colr): 
 4622      fl_pieslice(1, (x - r), (y - r), (2 * r), (2 * r), a1, a2, colr) 
 4623   
 4624   
 4625 -def fl_arc(x, y, r, a1, a2, colr): 
 4626      fl_pieslice(0, (x - r), (y - r), (2 * r), (2 * r), a1, a2, colr) 
 4627   
 4628   
 4629  # High level drawing routines 
 4630   
 4631 -def fl_drw_frame(style, x, y, w, h, colr, bw): 
 4632      """ fl_drw_frame(style, x, y, w, h, colr, bw) 
 4633      """ 
 4634   
 4635      _fl_drw_frame = cfuncproto( 
 4636              load_so_libforms(), "fl_drw_frame",\ 
 4637              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 
 4638              FL_COLOR, cty.c_int],\ 
 4639              """void fl_drw_frame(int style, FL_Coord x, FL_Coord y, 
 4640                 FL_Coord w, FL_Coord h, FL_COLOR c, int bw) 
 4641              """) 
 4642      check_admitted_listvalues(colr, COLOR_list) 
 4643      istyle = convert_to_int(style) 
 4644      ix = convert_to_FL_Coord(x) 
 4645      iy = convert_to_FL_Coord(y) 
 4646      iw = convert_to_FL_Coord(w) 
 4647      ih = convert_to_FL_Coord(h) 
 4648      ulcolr = convert_to_FL_COLOR(colr) 
 4649      ibw = convert_to_int(bw) 
 4650      keep_elem_refs(style, x, y, w, h, colr, bw, istyle, ix, iy, iw, 
 4651                     ih, ulcolr, ibw) 
 4652      _fl_drw_frame(istyle, ix, iy, iw, ih, ulcolr, ibw) 
 4653   
 4654   
 4655 -def fl_drw_checkbox(boxtype, x, y, w, h, colr, bw): 
 4656      """ fl_drw_checkbox(boxtype, x, y, w, h, colr, bw) 
 4657      """ 
 4658   
 4659      _fl_drw_checkbox = cfuncproto( 
 4660              load_so_libforms(), "fl_drw_checkbox",\ 
 4661              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 
 4662              FL_COLOR, cty.c_int],\ 
 4663              """void fl_drw_checkbox(int type, FL_Coord x, FL_Coord y, 
 4664                 FL_Coord w, FL_Coord h, FL_COLOR col, int bw) 
 4665              """) 
 4666      check_admitted_listvalues(colr, COLOR_list) 
 4667      iboxtype = convert_to_int(boxtype) 
 4668      ix = convert_to_FL_Coord(x) 
 4669      iy = convert_to_FL_Coord(y) 
 4670      iw = convert_to_FL_Coord(w) 
 4671      ih = convert_to_FL_Coord(h) 
 4672      ulcolr = convert_to_FL_COLOR(colr) 
 4673      ibw = convert_to_int(bw) 
 4674      keep_elem_refs(boxtype, x, y, w, h, colr, bw, iboxtype, ix, iy, iw, 
 4675                     ih, ulcolr, ibw) 
 4676      _fl_drw_checkbox(iboxtype, ix, iy, iw, ih, ulcolr, ibw) 
 4677   
 4678   
 4679  # Interfaces 
 4680   
 4681 -def fl_get_fontstruct(style, size): 
 4682      """ fl_get_fontstruct(style, size) -> XFontStruct class 
 4683      """ 
 4684   
 4685      _fl_get_fontstruct = cfuncproto( 
 4686              load_so_libforms(), "fl_get_fontstruct",\ 
 4687              cty.POINTER(XFontStruct), [cty.c_int, cty.c_int],\ 
 4688              """)XFontStruct * fl_get_fontstruct(int style, int size) 
 4689              """) 
 4690      istyle = convert_to_int(style) 
 4691      isize = convert_to_int(size) 
 4692      keep_elem_refs(style, size, istyle, isize) 
 4693      retval = _fl_get_fontstruct(istyle, isize) 
 4694      return retval 
 4695   
 4696   
 4697  fl_get_font_struct = fl_get_fontstruct 
 4698  fl_get_fntstruct = fl_get_font_struct 
 4699   
 4700   
 4701  #def fl_get_mouse(x, y, keymask)       *API change* 
 4702 -def fl_get_mouse(): 
 4703      """ fl_get_mouse() -> window, x, y, keymask 
 4704      """ 
 4705   
 4706      _fl_get_mouse = cfuncproto( 
 4707              load_so_libforms(), "fl_get_mouse",\ 
 4708              Window, [cty.POINTER(FL_Coord), cty.POINTER(FL_Coord),\ 
 4709              cty.POINTER(cty.c_uint)],\ 
 4710              """Window fl_get_mouse(FL_Coord * x, FL_Coord * y, 
 4711                unsigned int * keymask) 
 4712              """) 
 4713      x, px = make_FL_Coord_and_pointer() 
 4714      y, py = make_FL_Coord_and_pointer() 
 4715      keymask, pkeymask = make_uint_and_pointer() 
 4716      keep_elem_refs(x, y, keymask, px, py, pkeymask) 
 4717      retval = _fl_get_mouse(px, py, pkeymask) 
 4718      return retval, x, y, keymask 
 4719   
 4720   
 4721 -def fl_set_mouse(mx, my): 
 4722      """ fl_set_mouse(mx, my) 
 4723      """ 
 4724   
 4725      _fl_set_mouse = cfuncproto( 
 4726              load_so_libforms(), "fl_set_mouse",\ 
 4727              None, [FL_Coord, FL_Coord],\ 
 4728              """void fl_set_mouse(FL_Coord mx, FL_Coord my) 
 4729              """) 
 4730      imx = convert_to_int(mx) 
 4731      imy = convert_to_int(my) 
 4732      keep_elem_refs(mx, my, imx, imy) 
 4733      _fl_set_mouse(imx, imy) 
 4734   
 4735   
 4736  #def fl_get_win_mouse(win, x, y, keymask)       *API change* 
 4737 -def fl_get_win_mouse(win): 
 4738      """ fl_get_win_mouse(win) -> window, x, y, keymask 
 4739      """ 
 4740   
 4741      _fl_get_win_mouse = cfuncproto( 
 4742              load_so_libforms(), "fl_get_win_mouse",\ 
 4743              Window, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord),\ 
 4744              cty.POINTER(cty.c_uint)],\ 
 4745              """Window fl_get_win_mouse(Window win, FL_Coord * x, FL_Coord * y, 
 4746              unsigned int * keymask) 
 4747              """) 
 4748      ulwin = convert_to_Window(win) 
 4749      x, px = make_FL_Coord_and_pointer() 
 4750      y, py = make_FL_Coord_and_pointer() 
 4751      keymask, pkeymask = make_uint_and_pointer() 
 4752      keep_elem_refs(win, x, y, keymask, ulwin, px, py, pkeymask) 
 4753      retval = _fl_get_win_mouse(ulwin, px, py, pkeymask) 
 4754      return retval, x, y, keymask 
 4755   
 4756   
 4757  #def fl_get_form_mouse(fm, x, y, keymask)       *API change* 
 4758 -def fl_get_form_mouse(pForm): 
 4759      """ fl_get_form_mouse(pForm) -> window, x, y, keymask 
 4760   
 4761          @param pForm : pointer to form 
 4762      """ 
 4763   
 4764      _fl_get_form_mouse = cfuncproto( 
 4765              load_so_libforms(), "fl_get_form_mouse",\ 
 4766              Window, [cty.POINTER(FL_FORM), cty.POINTER(FL_Coord),\ 
 4767              cty.POINTER(FL_Coord), cty.POINTER(cty.c_uint)],\ 
 4768              """Window fl_get_form_mouse(FL_FORM * fm, FL_Coord * x, 
 4769                 FL_Coord * y, unsigned int * keymask) 
 4770              """) 
 4771      x, px = make_FL_Coord_and_pointer() 
 4772      y, py = make_FL_Coord_and_pointer() 
 4773      keymask, pkeymask = make_uint_and_pointer() 
 4774      keep_elem_refs(pForm, x, y, keymask) 
 4775      retval = _fl_get_form_mouse(pForm, px, py, pkeymask) 
 4776      return retval, x, y, keymask 
 4777   
 4778   
 4779 -def fl_win_to_form(win): 
 4780      """ 
 4781          fl_win_to_form(win) -> pForm 
 4782   
 4783          Returns the form that's shown in win. 
 4784   
 4785          @param win  : window id whose form is shown 
 4786      """ 
 4787   
 4788      _fl_win_to_form = cfuncproto( 
 4789              load_so_libforms(), "fl_win_to_form", 
 4790              cty.POINTER(FL_FORM), [Window],\ 
 4791              """FL_FORM * fl_win_to_form(Window win) 
 4792              """) 
 4793      ulwin = convert_to_Window(win) 
 4794      keep_elem_refs(win, ulwin) 
 4795      retval = _fl_win_to_form(ulwin) 
 4796      return retval 
 4797   
 4798   
 4799 -def fl_set_form_icon(pForm, icon, mask): 
 4800      """ fl_set_form_icon(pForm, icon, mask) 
 4801   
 4802          @param pForm : pointer to form 
 4803      """ 
 4804   
 4805      _fl_set_form_icon = cfuncproto( 
 4806              load_so_libforms(), "fl_set_form_icon",\ 
 4807              None, [cty.POINTER(FL_FORM), Pixmap, Pixmap],\ 
 4808              """void fl_set_form_icon(FL_FORM * form, Pixmap p, Pixmap m) 
 4809              """) 
 4810      ulicon = convert_to_Pixmap(icon) 
 4811      ulmask = convert_to_Pixmap(mask) 
 4812      keep_elem_refs(pForm, icon, mask, ulicon, ulmask) 
 4813      _fl_set_form_icon(pForm, ulicon, ulmask) 
 4814   
 4815   
 4816  #def fl_get_decoration_sizes(pForm, top, right, bottom, left)       *API change* 
 4817 -def fl_get_decoration_sizes(pForm): 
 4818      """ 
 4819          fl_get_decoration_sizes(pForm) -> num., top, right, bottom, left 
 4820   
 4821          Returns the sizes of the "decorations" the window manager puts around 
 4822          a form's window. Returns 0 on success and 1 if the form isn't visible 
 4823          or it's a form embedded into another form. 
 4824   
 4825          @param pForm : pointer to form 
 4826      """ 
 4827   
 4828      _fl_get_decoration_sizes = cfuncproto( 
 4829              load_so_libforms(), "fl_get_decoration_sizes", 
 4830              cty.c_int, [cty.POINTER(FL_FORM), cty.POINTER(cty.c_int),\ 
 4831              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
 4832              cty.POINTER(cty.c_int)],\ 
 4833              """int fl_get_decoration_sizes(FL_FORM * form, int * top, 
 4834                 int * right, int * bottom, int * left) 
 4835              """) 
 4836      top, ptop = make_int_and_pointer() 
 4837      right, pright = make_int_and_pointer() 
 4838      bottom, pbottom = make_int_and_pointer() 
 4839      left, pleft = make_int_and_pointer() 
 4840      keep_elem_refs(pForm, top, right, bottom, left, ptop, pright, pbottom, 
 4841                     pleft) 
 4842      retval = _fl_get_decoration_sizes(pForm, ptop, pright, pbottom, pleft) 
 4843      return retval, top, right, bottom, left 
 4844   
 4845   
 4846 -def fl_raise_form(pForm): 
 4847      """ 
 4848           fl_raise_form(pForm) 
 4849   
 4850           @param pForm : pouinter to form to be raised 
 4851      """ 
 4852   
 4853      _fl_raise_form = cfuncproto( 
 4854              load_so_libforms(), "fl_raise_form",\ 
 4855              None, [cty.POINTER(FL_FORM)],\ 
 4856              """void fl_raise_form(FL_FORM * p1) 
 4857              """) 
 4858      keep_elem_refs(pForm) 
 4859      _fl_raise_form(pForm) 
 4860   
 4861   
 4862 -def fl_lower_form(pForm): 
 4863      """ 
 4864           fl_lower_form(pForm) 
 4865   
 4866           @param pForm : pouinter to form to be lowered 
 4867      """ 
 4868   
 4869      _fl_lower_form = cfuncproto( 
 4870              load_so_libforms(), "fl_lower_form",\ 
 4871              None, [cty.POINTER(FL_FORM)],\ 
 4872              """void fl_lower_form(FL_FORM * p1) 
 4873              """) 
 4874      keep_elem_refs(pForm) 
 4875      _fl_lower_form(pForm) 
 4876   
 4877   
 4878 -def fl_set_foreground(gc, colr): 
 4879      """ 
 4880          fl_set_foreground(gc, colr) 
 4881   
 4882          @param gc : ? 
 4883          @param colr : color value to be set as foreground 
 4884      """ 
 4885   
 4886      _fl_set_foreground = cfuncproto( 
 4887              load_so_libforms(), "fl_set_foreground",\ 
 4888              None, [GC, FL_COLOR],\ 
 4889              """oid fl_set_foreground(GC gc, FL_COLOR col) 
 4890              """) 
 4891      ulcolr = convert_to_FL_COLOR(colr) 
 4892      keep_elem_refs(gc, colr, ulcolr) 
 4893      _fl_set_foreground(gc, ulcolr) 
 4894   
 4895   
 4896 -def fl_set_background(gc, colr): 
 4897      """ 
 4898          fl_set_background(gc, colr) 
 4899   
 4900          @param gc : ? 
 4901          @param colr : color value to be set as background 
 4902      """ 
 4903   
 4904      _fl_set_background = cfuncproto( 
 4905              load_so_libforms(), "fl_set_background",\ 
 4906              None, [GC, FL_COLOR],\ 
 4907              """oid fl_set_background(GC gc, FL_COLOR col) 
 4908              """) 
 4909      ulcolr = convert_to_FL_COLOR(colr) 
 4910      keep_elem_refs(gc, colr, ulcolr) 
 4911      _fl_set_background(gc, ulcolr) 
 4912   
 4913   
 4914  # General windowing support 
 4915   
 4916 -def fl_wincreate(title): 
 4917      """ 
 4918          fl_wincreate(title) -> window ID 
 4919   
 4920          Creates a window with a specified title. 
 4921   
 4922          @param title : title of the window 
 4923      """ 
 4924   
 4925      _fl_wincreate = cfuncproto( 
 4926              load_so_libforms(), "fl_wincreate",\ 
 4927              Window, [STRING],\ 
 4928              """Window fl_wincreate(const char * label) 
 4929              """) 
 4930      stitle = convert_to_string(title) 
 4931      keep_elem_refs(title, stitle) 
 4932      retval = _fl_wincreate(stitle) 
 4933      return retval 
 4934   
 4935   
 4936 -def fl_winshow(win): 
 4937      """ 
 4938          fl_winshow(win) -> window 
 4939   
 4940          Shows the window (created with fl_wincreate) 
 4941   
 4942          @param win : window id to show 
 4943      """ 
 4944   
 4945      _fl_winshow = cfuncproto( 
 4946              load_so_libforms(), "fl_winshow",\ 
 4947              Window, [Window],\ 
 4948              """Window fl_winshow(Window win) 
 4949              """) 
 4950      ulwin = convert_to_Window(win) 
 4951      keep_elem_refs(win, ulwin) 
 4952      retval = _fl_winshow(ulwin) 
 4953      return retval 
 4954   
 4955   
 4956 -def fl_winopen(title): 
 4957      """ 
 4958          fl_winopen(title) -> window 
 4959          Opens (creates and shows) a toplevel window with the specified 
 4960          title. 
 4961   
 4962          @param title : title of the window 
 4963      """ 
 4964   
 4965      _fl_winopen = cfuncproto( 
 4966              load_so_libforms(), "fl_winopen", \ 
 4967              Window, [STRING], \ 
 4968              """Window fl_winopen(const char * label) 
 4969              """) 
 4970      stitle = convert_to_string(title) 
 4971      keep_elem_refs(title, stitle) 
 4972      retval = _fl_winopen(stitle) 
 4973      return retval 
 4974   
 4975   
 4976 -def fl_winhide(win): 
 4977      """ fl_winhide(win) 
 4978      """ 
 4979   
 4980      _fl_winhide = cfuncproto( 
 4981              load_so_libforms(), "fl_winhide", \ 
 4982              None, [Window], \ 
 4983              """void fl_winhide(Window win) 
 4984              """) 
 4985      ulwin = convert_to_Window(win) 
 4986      keep_elem_refs(win, ulwin) 
 4987      _fl_winhide(ulwin) 
 4988   
 4989   
 4990 -def fl_winclose(win): 
 4991      """ fl_winclose(win) 
 4992      """ 
 4993   
 4994      _fl_winclose = cfuncproto( 
 4995              load_so_libforms(), "fl_winclose", \ 
 4996              None, [Window], \ 
 4997              """void fl_winclose(Window win) 
 4998              """) 
 4999      ulwin = convert_to_Window(win) 
 5000      keep_elem_refs(win, ulwin) 
 5001      _fl_winclose(win, ulwin) 
 5002   
 5003   
 5004 -def fl_winset(win): 
 5005      """ fl_winset(win) 
 5006      """ 
 5007   
 5008      _fl_winset = cfuncproto( 
 5009              load_so_libforms(), "fl_winset", \ 
 5010              None, [Window], \ 
 5011              """void fl_winset(Window win) 
 5012              """) 
 5013      ulwin = convert_to_Window(win) 
 5014      keep_elem_refs(win, ulwin) 
 5015      _fl_winset(ulwin) 
 5016   
 5017   
 5018 -def fl_winreparent(win, winnewparent): 
 5019      """ 
 5020          fl_winreparent(win, winnewparent) -> num. 
 5021   
 5022          Makes a toplevel window a subwindow of another (new parent) window; 
 5023          both the window and the parent window must be valid ones. 
 5024   
 5025          @param win : window to be made a subwindow 
 5026          @param winnewparent : window to become its new parent window 
 5027      """ 
 5028   
 5029      _fl_winreparent = cfuncproto( 
 5030              load_so_libforms(), "fl_winreparent", \ 
 5031              cty.c_int, [Window, Window], \ 
 5032              """int fl_winreparent(Window win, Window new_parent) 
 5033              """) 
 5034      ulwin = convert_to_Window(win) 
 5035      ulwinnewparent = convert_to_Window(winnewparent) 
 5036      keep_elem_refs(win, winnewparent, ulwin, ulwinnewparent) 
 5037      retval = _fl_winreparent(ulwin, ulwinnewparent) 
 5038      return retval 
 5039   
 5040   
 5041 -def fl_winfocus(win): 
 5042      """ fl_winfocus(win) 
 5043      """ 
 5044   
 5045      _fl_winfocus = cfuncproto( 
 5046              load_so_libforms(), "fl_winfocus", \ 
 5047              None, [Window], \ 
 5048              """void fl_winfocus(Window win) 
 5049              """) 
 5050      ulwin = convert_to_Window(win) 
 5051      keep_elem_refs(win, ulwin) 
 5052      _fl_winfocus(ulwin) 
 5053   
 5054   
 5055 -def fl_winget(): 
 5056      """ fl_winget() -> window 
 5057      """ 
 5058   
 5059      _fl_winget = cfuncproto( 
 5060              load_so_libforms(), "fl_winget", \ 
 5061              Window, [], \ 
 5062              """Window fl_winget() 
 5063              """) 
 5064      retval = _fl_winget() 
 5065      return retval 
 5066   
 5067   
 5068 -def fl_iconify(win): 
 5069      """ fl_iconify(win) -> num. 
 5070      """ 
 5071   
 5072      _fl_iconify = cfuncproto( 
 5073              load_so_libforms(), "fl_iconify", \ 
 5074              cty.c_int, [Window], \ 
 5075              """int fl_iconify(Window win) 
 5076              """) 
 5077      ulwin = convert_to_Window(win) 
 5078      keep_elem_refs(win, ulwin) 
 5079      retval = _fl_iconify(ulwin) 
 5080      return retval 
 5081   
 5082   
 5083 -def fl_winresize(win, neww, newh): 
 5084      """ fl_winresize(win, neww, newh) 
 5085   
 5086          @param win : window to resize 
 5087          @param neww : new width 
 5088          @param newh : new height 
 5089      """ 
 5090   
 5091      _fl_winresize = cfuncproto( 
 5092              load_so_libforms(), "fl_winresize", \ 
 5093              None, [Window, FL_Coord, FL_Coord], \ 
 5094              """void fl_winresize(Window win, FL_Coord neww, FL_Coord newh) 
 5095              """) 
 5096      ulwin = convert_to_Window(win) 
 5097      ineww = convert_to_int(neww) 
 5098      inewh = convert_to_int(newh) 
 5099      keep_elem_refs(win, neww, newh, ulwin, ineww, inewh) 
 5100      _fl_winresize(ulwin, ineww, inewh) 
 5101   
 5102   
 5103 -def fl_winmove(win, dx, dy): 
 5104      """ fl_winmove(win, dx, dy) 
 5105   
 5106          @param win : window to move to a new position 
 5107          @param dx : new horizontal position 
 5108          @param dy : new vertical position 
 5109      """ 
 5110   
 5111      _fl_winmove = cfuncproto( 
 5112              load_so_libforms(), "fl_winmove", \ 
 5113              None, [Window, FL_Coord, FL_Coord], \ 
 5114              """void fl_winmove(Window win, FL_Coord dx, FL_Coord dy) 
 5115              """) 
 5116      ulwin = convert_to_Window(win) 
 5117      idx = convert_to_int(dx) 
 5118      idy = convert_to_int(dy) 
 5119      keep_elem_refs(win, dx, dy, ulwin, idx, idy) 
 5120      _fl_winmove(ulwin, idx, idy) 
 5121   
 5122   
 5123 -def fl_winreshape(win, dx, dy, w, h): 
 5124      """ fl_winreshape(win, dx, dy, w, h) 
 5125      """ 
 5126   
 5127      _fl_winreshape = cfuncproto( 
 5128              load_so_libforms(), "fl_winreshape", \ 
 5129              None, [Window, FL_Coord, FL_Coord, FL_Coord, FL_Coord], \ 
 5130              """void fl_winreshape(Window win, FL_Coord dx, FL_Coord dy, 
 5131                 FL_Coord w, FL_Coord h) 
 5132              """) 
 5133      ulwin = convert_to_Window(win) 
 5134      idx = convert_to_int(dx) 
 5135      idy = convert_to_int(dy) 
 5136      iw = convert_to_FL_Coord(w) 
 5137      ih = convert_to_FL_Coord(h) 
 5138      keep_elem_refs(win, dx, dy, w, h, ulwin, idx, idy, iw, ih) 
 5139      _fl_winreshape(ulwin, idx, idy, iw, ih) 
 5140   
 5141   
 5142 -def fl_winicon(win, icon, mask): 
 5143      """ 
 5144          fl_winicon(win, icon, mask) 
 5145   
 5146          Installs an icon for the window. 
 5147   
 5148          @param win : window 
 5149          @param icon : pixmap icon to be installed in window 
 5150          @param mask : mask 
 5151      """ 
 5152   
 5153      _fl_winicon = cfuncproto( 
 5154              load_so_libforms(), "fl_winicon", \ 
 5155              None, [Window, Pixmap, Pixmap], \ 
 5156              """void fl_winicon(Window win, Pixmap p, Pixmap m) 
 5157              """) 
 5158      ulwin = convert_to_Window(win) 
 5159      ulicon = convert_to_Pixmap(icon) 
 5160      ulmask = convert_to_Pixmap(mask) 
 5161      keep_elem_refs(win, icon, mask, ulwin, ulicon, ulmask) 
 5162      _fl_winicon(ulwin, ulicon, ulmask) 
 5163   
 5164   
 5165 -def fl_winbackground(win, bkcolr): 
 5166      """ 
 5167          fl_winbackground(win, bkcolr) 
 5168   
 5169          Sets the background of the window to a certain color. 
 5170   
 5171          @param win : window 
 5172          @param bkcolr : background color to be set 
 5173      """ 
 5174   
 5175      _fl_winbackground = cfuncproto( 
 5176              load_so_libforms(), "fl_winbackground", \ 
 5177              None, [Window, FL_COLOR], \ 
 5178              """void fl_winbackground(Window win, FL_COLOR bk) 
 5179              """) 
 5180      check_admitted_listvalues(bkcolr, COLOR_list) 
 5181      ulwin = convert_to_Window(win) 
 5182      ulbkcolr = convert_to_FL_COLOR(bkcolr) 
 5183      keep_elem_refs(win, bkcolr, ulwin, ulbkcolr) 
 5184      _fl_winbackground(ulwin, ulbkcolr) 
 5185   
 5186   
 5187 -def fl_winstepsize(win, dx, dy): 
 5188      """ fl_winstepsize(win, dx, dy) 
 5189      """ 
 5190   
 5191      _fl_winstepsize = cfuncproto( 
 5192              load_so_libforms(), "fl_winstepsize", \ 
 5193              None, [Window, FL_Coord, FL_Coord], \ 
 5194              """void fl_winstepsize(Window win, FL_Coord dx, FL_Coord dy) 
 5195              """) 
 5196      ulwin = convert_to_Window(win) 
 5197      idx = convert_to_int(dx) 
 5198      idy = convert_to_int(dy) 
 5199      keep_elem_refs(win, dx, dy, ulwin, idx, idy) 
 5200      _fl_winstepsize(ulwin, idx, idy) 
 5201   
 5202   
 5203  fl_winstepunit = fl_winstepsize 
 5204  fl_set_winstepunit = fl_winstepsize 
 5205   
 5206   
 5207 -def fl_winisvalid(win): 
 5208      """ fl_winisvalid(win) -> num. 
 5209      """ 
 5210   
 5211      _fl_winisvalid = cfuncproto( 
 5212              load_so_libforms(), "fl_winisvalid", \ 
 5213              cty.c_int, [Window], \ 
 5214              """int fl_winisvalid(Window win) 
 5215              """) 
 5216      ulwin = convert_to_Window(win) 
 5217      keep_elem_refs(win, ulwin) 
 5218      retval = _fl_winisvalid(ulwin) 
 5219      return retval 
 5220   
 5221   
 5222 -def fl_wintitle(win, title): 
 5223      """ 
 5224          fl_wintitle(win, title) 
 5225   
 5226          Changes the window title (and its associated icon title). 
 5227   
 5228          @param win : window 
 5229          @param title : window title to be set 
 5230      """ 
 5231   
 5232      _fl_wintitle = cfuncproto( 
 5233              load_so_libforms(), "fl_wintitle", \ 
 5234              None, [Window, STRING], \ 
 5235              """void fl_wintitle(Window win, const char * title) 
 5236              """) 
 5237      ulwin = convert_to_Window(win) 
 5238      stitle = convert_to_string(title) 
 5239      keep_elem_refs(win, title, ulwin, stitle) 
 5240      _fl_wintitle(ulwin, stitle) 
 5241   
 5242   
 5243 -def fl_winicontitle(win, title): 
 5244      """ 
 5245          fl_winicontitle(win, title) 
 5246   
 5247          Changes only the icon title for the window. 
 5248   
 5249          @param win : window 
 5250          @param title : icon title to be set 
 5251      """ 
 5252   
 5253      _fl_winicontitle = cfuncproto( 
 5254              load_so_libforms(), "fl_winicontitle", \ 
 5255              None, [Window, STRING], \ 
 5256              """void fl_winicontitle(Window win, const char * title) 
 5257              """) 
 5258      ulwin = convert_to_Window(win) 
 5259      stitle = convert_to_string(title) 
 5260      keep_elem_refs(win, title, ulwin, stitle) 
 5261      _fl_winicontitle(ulwin, stitle) 
 5262   
 5263   
 5264 -def fl_winposition(x, y): 
 5265      """ 
 5266          fl_winposition(x, y) 
 5267   
 5268          Sets the position of a window to be opened. 
 5269   
 5270          @param x : horizontal position of the window (upper-left corner) 
 5271          @param y : vertical position of the window (upper-left corner) 
 5272      """ 
 5273   
 5274      _fl_winposition = cfuncproto( 
 5275              load_so_libforms(), "fl_winposition", 
 5276              None, [FL_Coord, FL_Coord], 
 5277              """void fl_winposition(FL_Coord x, FL_Coord y) 
 5278              """) 
 5279      ix = convert_to_FL_Coord(x) 
 5280      iy = convert_to_FL_Coord(y) 
 5281      keep_elem_refs(x, y, ix, iy) 
 5282      _fl_winposition(ix, iy) 
 5283   
 5284   
 5285  fl_pref_winposition = fl_winposition 
 5286  fl_win_background = fl_winbackground 
 5287  fl_set_winstepunit = fl_winstepunit 
 5288   
 5289   
 5290 -def fl_winminsize(win, w, h): 
 5291      """ 
 5292          fl_winminsize(win, w, h) 
 5293   
 5294          Sets a constraint for a resizable window whose size will be within a 
 5295          range not less than minumum (before calling fl_winopen). 
 5296   
 5297          @param win : window to be set 
 5298          @param w : minimum width of window 
 5299          @param h : minimum height of window 
 5300      """ 
 5301   
 5302      _fl_winminsize = cfuncproto( 
 5303              load_so_libforms(), "fl_winminsize", 
 5304              None, [Window, FL_Coord, FL_Coord], 
 5305              """void fl_winminsize(Window win, FL_Coord w, FL_Coord h) 
 5306              """) 
 5307      ulwin = convert_to_Window(win) 
 5308      iw = convert_to_FL_Coord(w) 
 5309      ih = convert_to_FL_Coord(h) 
 5310      keep_elem_refs(win, w, h, ulwin, iw, ih) 
 5311      _fl_winminsize(ulwin, iw, ih) 
 5312   
 5313   
 5314 -def fl_winmaxsize(win, w, h): 
 5315      """ 
 5316          fl_winmaxsize(win, w, h) 
 5317   
 5318          Sets a constraint for a resizable window whose size will be within a 
 5319          range not bigger than maximum (before calling fl_winopen). 
 5320   
 5321          @param win : window to be set 
 5322          @param w : maximum width of window 
 5323          @param h : maximum height of window 
 5324      """ 
 5325   
 5326      _fl_winmaxsize = cfuncproto( 
 5327              load_so_libforms(), "fl_winmaxsize", 
 5328              None, [Window, FL_Coord, FL_Coord], 
 5329              """void fl_winmaxsize(Window win, FL_Coord w, FL_Coord h) 
 5330              """) 
 5331      ulwin = convert_to_Window(win) 
 5332      iw = convert_to_FL_Coord(w) 
 5333      ih = convert_to_FL_Coord(h) 
 5334      keep_elem_refs(win, w, h, ulwin, iw, ih) 
 5335      _fl_winmaxsize(ulwin, iw, ih) 
 5336   
 5337   
 5338 -def fl_winaspect(win, x, y): 
 5339      """ 
 5340          fl_winaspect(win, x, y) 
 5341   
 5342          Sets the aspect ratio of the window for later interactive resizing. 
 5343   
 5344          @param win : window to be set 
 5345          @param x : horizontal aspect ratio 
 5346          @param y : vertical aspect ratio 
 5347      """ 
 5348   
 5349      _fl_winaspect = cfuncproto( 
 5350              load_so_libforms(), "fl_winaspect", 
 5351              None, [Window, FL_Coord, FL_Coord], 
 5352              """void fl_winaspect(Window win, FL_Coord x, FL_Coord y) 
 5353              """) 
 5354      ulwin = convert_to_Window(win) 
 5355      ix = convert_to_FL_Coord(x) 
 5356      iy = convert_to_FL_Coord(y) 
 5357      keep_elem_refs(win, x, y, ulwin, ix, iy) 
 5358      _fl_winaspect(ulwin, ix, iy) 
 5359   
 5360   
 5361 -def fl_reset_winconstraints(win): 
 5362      """ fl_reset_winconstraints(win) 
 5363      """ 
 5364   
 5365      _fl_reset_winconstraints = cfuncproto( 
 5366              load_so_libforms(), "fl_reset_winconstraints", 
 5367              None, [Window], 
 5368              """void fl_reset_winconstraints(Window win) 
 5369              """) 
 5370      ulwin = convert_to_Window(win) 
 5371      keep_elem_refs(win) 
 5372      _fl_reset_winconstraints(ulwin) 
 5373   
 5374   
 5375 -def fl_winsize(w, h): 
 5376      """ 
 5377          fl_winsize(w, h) 
 5378   
 5379          Sets the preferred window size (before calling fl_winopen), and makes 
 5380          the window non-resizeable. 
 5381   
 5382          @param w : width of the window in pixels 
 5383          @param h : height of the window in pixels 
 5384      """ 
 5385   
 5386      _fl_winsize = cfuncproto( 
 5387              load_so_libforms(), "fl_winsize", 
 5388              None, [FL_Coord, FL_Coord], 
 5389              """void fl_winsize(FL_Coord w, FL_Coord h) 
 5390              """) 
 5391      iw = convert_to_FL_Coord(w) 
 5392      ih = convert_to_FL_Coord(h) 
 5393      keep_elem_refs(w, h, iw, ih) 
 5394      _fl_winsize(iw, ih) 
 5395   
 5396   
 5397 -def fl_initial_winsize(w, h): 
 5398      """ 
 5399          fl_initial_winsize(w, h) 
 5400   
 5401          Sets the preferred window size (before calling fl_winopen). 
 5402   
 5403          @param w : width of the window in pixels 
 5404          @param h : height of the window in pixels 
 5405      """ 
 5406   
 5407      _fl_initial_winsize = cfuncproto( 
 5408              load_so_libforms(), "fl_initial_winsize", 
 5409              None, [FL_Coord, FL_Coord], 
 5410              """void fl_initial_winsize(FL_Coord w, FL_Coord h) 
 5411              """) 
 5412      iw = convert_to_FL_Coord(w) 
 5413      ih = convert_to_FL_Coord(h) 
 5414      keep_elem_refs(w, h, iw, ih) 
 5415      _fl_initial_winsize(iw, ih) 
 5416   
 5417   
 5418  fl_pref_winsize = fl_winsize 
 5419   
 5420   
 5421 -def fl_initial_winstate(state): 
 5422      """ fl_initial_winstate(state) 
 5423      """ 
 5424   
 5425      _fl_initial_winstate = cfuncproto( 
 5426              load_so_libforms(), "fl_initial_winstate", 
 5427              None, [cty.c_int], 
 5428              """void fl_initial_winstate(int state) 
 5429              """) 
 5430      istate = convert_to_int(state) 
 5431      keep_elem_refs(state, istate) 
 5432      _fl_initial_winstate(istate) 
 5433   
 5434   
 5435 -def fl_create_colormap(pXVisualInfo, nfill): 
 5436      """ fl_create_colormap(pXVisualInfo, nfill) -> colormap 
 5437      """ 
 5438   
 5439      _fl_create_colormap = cfuncproto( 
 5440              load_so_libforms(), "fl_create_colormap", 
 5441              Colormap, [cty.POINTER(XVisualInfo), cty.c_int], 
 5442              """)Colormap fl_create_colormap(XVisualInfo * xv, int nfill) 
 5443              """) 
 5444      infill = convert_to_int(nfill) 
 5445      keep_elem_refs(pXVisualInfo, nfill, infill) 
 5446      retval = _fl_create_colormap(pXVisualInfo, infill) 
 5447      return retval 
 5448   
 5449   
 5450 -def fl_wingeometry(x, y, w, h): 
 5451      """ 
 5452          fl_wingeometry(x, y, w, h) 
 5453   
 5454          Sets the initial geometry (position and size) of the window to be 
 5455          opened; the window will not be resizable. 
 5456   
 5457          @param x : horizontal position of the window (upper-left corner) 
 5458          @param y : vertical position of the window (upper-left corner) 
 5459          @param w : width of the window in pixels 
 5460          @param h : height of the window in pixels 
 5461      """ 
 5462   
 5463      _fl_wingeometry = cfuncproto( 
 5464              load_so_libforms(), "fl_wingeometry", 
 5465              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 
 5466              """void fl_wingeometry(FL_Coord x, FL_Coord y, FL_Coord w, 
 5467                 FL_Coord h) 
 5468              """) 
 5469      ix = convert_to_FL_Coord(x) 
 5470      iy = convert_to_FL_Coord(y) 
 5471      iw = convert_to_FL_Coord(w) 
 5472      ih = convert_to_FL_Coord(h) 
 5473      keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 
 5474      _fl_wingeometry(ix, iy, iw, ih) 
 5475   
 5476   
 5477  fl_pref_wingeometry = fl_wingeometry 
 5478   
 5479   
 5480 -def fl_initial_wingeometry(x, y, w, h): 
 5481      """ 
 5482          fl_initial_wingeometry(x, y, w, h) 
 5483   
 5484          Sets the initial geometry (position and size) of the window to be 
 5485          opened. 
 5486   
 5487          @param x : horizontal position of the window (upper-left corner) 
 5488          @param y : vertical position of the window (upper-left corner) 
 5489          @param w : width of the window in pixels 
 5490          @param h : height of the window in pixels 
 5491      """ 
 5492   
 5493      _fl_initial_wingeometry = cfuncproto( 
 5494              load_so_libforms(), "fl_initial_wingeometry", 
 5495              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 
 5496              """void fl_initial_wingeometry(FL_Coord x, FL_Coord y, 
 5497                 FL_Coord w, FL_Coord h) 
 5498              """) 
 5499      ix = convert_to_FL_Coord(x) 
 5500      iy = convert_to_FL_Coord(y) 
 5501      iw = convert_to_FL_Coord(w) 
 5502      ih = convert_to_FL_Coord(h) 
 5503      keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 
 5504      _fl_initial_wingeometry(ix, iy, iw, ih) 
 5505   
 5506   
 5507 -def fl_noborder(): 
 5508      """ 
 5509          fl_noborder() 
 5510   
 5511          Suppresses the window manager's decoration (before creating the 
 5512          window). 
 5513      """ 
 5514   
 5515      _fl_noborder = cfuncproto( 
 5516              load_so_libforms(), "fl_noborder", 
 5517              None, [], 
 5518              """void fl_noborder() 
 5519              """) 
 5520      _fl_noborder() 
 5521   
 5522   
 5523 -def fl_transient(): 
 5524      """ 
 5525          fl_transient() 
 5526   
 5527          Makes a window a transient one (before creating the window). 
 5528      """ 
 5529   
 5530      _fl_transient = cfuncproto( 
 5531              load_so_libforms(), "fl_transient", 
 5532              None, [], \ 
 5533              """void fl_transient() 
 5534              """) 
 5535      _fl_transient() 
 5536   
 5537   
 5538  #def fl_get_winsize(win, w, h)       *API change* 
 5539 -def fl_get_winsize(win): 
 5540      """ fl_get_winsize(win) -> width, height 
 5541   
 5542          @param win : window 
 5543      """ 
 5544   
 5545      _fl_get_winsize = cfuncproto( 
 5546              load_so_libforms(), "fl_get_winsize", 
 5547              None, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 
 5548              """void fl_get_winsize(Window win, FL_Coord * w, FL_Coord * h) 
 5549              """) 
 5550      ulwin = convert_to_Window(win) 
 5551      iw, pw = make_int_and_pointer() 
 5552      ih, ph = make_int_and_pointer() 
 5553      keep_elem_refs(win, ulwin, iw, ih, pw, ph) 
 5554      _fl_get_winsize(ulwin, pw, ph) 
 5555      return iw, ih 
 5556   
 5557   
 5558  #def fl_get_winorigin(win, x, y)       *API change* 
 5559 -def fl_get_winorigin(win): 
 5560      """ fl_get_winorigin(win) -> x, y 
 5561      """ 
 5562   
 5563      _fl_get_winorigin = cfuncproto( 
 5564              load_so_libforms(), "fl_get_winorigin", 
 5565              None, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 
 5566              """void fl_get_winorigin(Window win, FL_Coord * x, FL_Coord * y) 
 5567              """) 
 5568      ulwin = convert_to_Window(win) 
 5569      x, px = make_FL_Coord_and_pointer() 
 5570      y, py = make_FL_Coord_and_pointer() 
 5571      keep_elem_refs(win, ulwin, x, y, px, py) 
 5572      _fl_get_winorigin(win, px, py) 
 5573      return x, y 
 5574   
 5575   
 5576  #def fl_get_wingeometry(win, x, y, w, h)       *API change* 
 5577 -def fl_get_wingeometry(win): 
 5578      """ fl_get_wingeometry(win) -> x, y, w, h 
 5579   
 5580          @param win : window 
 5581      """ 
 5582   
 5583      _fl_get_wingeometry = cfuncproto( 
 5584              load_so_libforms(), "fl_get_wingeometry", 
 5585              None, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 
 5586              cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 
 5587              """void fl_get_wingeometry(Window win, FL_Coord * x, FL_Coord * y, 
 5588                 FL_Coord * w, FL_Coord * h) 
 5589              """) 
 5590      ulwin = convert_to_Window(win) 
 5591      x, px = make_FL_Coord_and_pointer() 
 5592      y, py = make_FL_Coord_and_pointer() 
 5593      w, pw = make_FL_Coord_and_pointer() 
 5594      h, ph = make_FL_Coord_and_pointer() 
 5595      keep_elem_refs(win, x, y, w, h, ulwin, px, py, pw, ph) 
 5596      _fl_get_wingeometry(ulwin, px, py, pw, ph) 
 5597      return x, y, w, h 
 5598   
 5599   
 5600  # For compatibility 
 5601  fl_get_win_size = fl_get_winsize 
 5602  fl_get_win_origin = fl_get_winorigin 
 5603  fl_get_win_geometry = fl_get_wingeometry 
 5604  fl_initial_winposition = fl_pref_winposition 
 5605   
 5606   
 5607 -def fl_get_display():       # NOT SURE 
 5608      return fl_display 
 5609   
 5610   
 5611 -def FL_FormDisplay(pForm):   # NOT SURE 
 5612      return fl_display 
 5613   
 5614   
 5615 -def FL_ObjectDisplay(object):   # NOT SURE 
 5616      return fl_display 
 5617   
 5618   
 5619 -def FL_IS_CANVAS(pObject): 
 5620      if (pObject[0].objclass == FL_CANVAS) or \ 
 5621          (pObject[0].objclass == FL_GLCANVAS): 
 5622          return True 
 5623      else: 
 5624          return False 
 5625   
 5626   
 5627  # The window an object belongs to - for drawing 
 5628 -def FL_ObjWin(pObject): 
 5629      if FL_IS_CANVAS(pObject): 
 5630          return fl_get_canvas_id(pObject) 
 5631      else: 
 5632          return pObject[0].form[0].window 
 5633   
 5634   
 5635 -def fl_get_real_object_window(pObject): 
 5636      """ fl_get_real_object_window(pObject) -> window 
 5637   
 5638          @param pObject : pointer to object 
 5639      """ 
 5640   
 5641      _fl_get_real_object_window = cfuncproto( 
 5642              load_so_libforms(), "fl_get_real_object_window", 
 5643              Window, [cty.POINTER(FL_OBJECT)], 
 5644              """Window fl_get_real_object_window(FL_OBJECT * ob) 
 5645              """) 
 5646      keep_elem_refs(pObject) 
 5647      retval = _fl_get_real_object_window(pObject) 
 5648      return retval 
 5649   
 5650   
 5651  FL_OBJECT_WID = FL_ObjWin 
 5652   
 5653   
 5654  # Replacements for X functions that access the event queue 
 5655   
 5656 -def fl_XNextEvent(pXEvent): 
 5657      """ fl_XNextEvent(pXEvent) -> event num. 
 5658      """ 
 5659   
 5660      _fl_XNextEvent = cfuncproto( 
 5661              load_so_libforms(), "fl_XNextEvent", 
 5662              cty.c_int, [cty.POINTER(XEvent)], 
 5663              """int fl_XNextEvent(XEvent * xev) 
 5664              """) 
 5665      keep_elem_refs(pXEvent) 
 5666      retval = _fl_XNextEvent(pXEvent) 
 5667      return retval 
 5668   
 5669   
 5670 -def fl_XPeekEvent(pXEvent): 
 5671      """ fl_XPeekEvent(pXEvent) -> event num. 
 5672      """ 
 5673   
 5674      _fl_XPeekEvent = cfuncproto( 
 5675              load_so_libforms(), "fl_XPeekEvent", 
 5676              cty.c_int, [cty.POINTER(XEvent)], 
 5677              """int fl_XPeekEvent(XEvent * xev) 
 5678              """) 
 5679      keep_elem_refs(pXEvent) 
 5680      retval = _fl_XPeekEvent(pXEvent) 
 5681      return retval 
 5682   
 5683   
 5684 -def fl_XEventsQueued(mode): 
 5685      """ fl_XEventsQueued(mode) -> event num. 
 5686      """ 
 5687   
 5688      _fl_XEventsQueued = cfuncproto( 
 5689              load_so_libforms(), "fl_XEventsQueued", 
 5690              cty.c_int, [cty.c_int], 
 5691              """int fl_XEventsQueued(int mode) 
 5692              """) 
 5693      imode = convert_to_int(mode) 
 5694      keep_elem_refs(mode, imode) 
 5695      retval = _fl_XEventsQueued(imode) 
 5696      return retval 
 5697   
 5698   
 5699 -def fl_XPutBackEvent(pXEvent): 
 5700      """ fl_XPutBackEvent(pXEvent) 
 5701      """ 
 5702   
 5703      _fl_XPutBackEvent = cfuncproto( 
 5704              load_so_libforms(), "fl_XPutBackEvent", 
 5705              None, [cty.POINTER(XEvent)], 
 5706              """void fl_XPutBackEvent(XEvent * xev) 
 5707              """) 
 5708      keep_elem_refs(pXEvent) 
 5709      _fl_XPutBackEvent(pXEvent) 
 5710   
 5711   
 5712 -def fl_last_event(): 
 5713      """ fl_last_event() -> event 
 5714      """ 
 5715   
 5716      _fl_last_event = cfuncproto( 
 5717              load_so_libforms(), "fl_last_event", 
 5718              cty.POINTER(XEvent), [], 
 5719              """const char * fl_last_event() 
 5720              """) 
 5721      retval = _fl_last_event() 
 5722      return retval 
 5723   
 5724   
 5725  FL_APPEVENT_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(XEvent), cty.c_void_p) 
 5726   
 5727 -def fl_set_event_callback(py_AppEventCb, userdata): 
 5728      """ 
 5729          fl_set_event_callback(py_AppEventCb, userdata) -> event callback 
 5730      """ 
 5731   
 5732      _fl_set_event_callback = cfuncproto( 
 5733              load_so_libforms(), "fl_set_event_callback", 
 5734              FL_APPEVENT_CB, [FL_APPEVENT_CB, cty.c_void_p], 
 5735              """FL_APPEVENT_CB fl_set_event_callback(FL_APPEVENT_CB callback, 
 5736                 void * user_data) 
 5737              """) 
 5738      c_AppEventCb = FL_APPEVENT_CB(py_AppEventCb) 
 5739      puserdata = cty.cast(userdata, cty.c_void_p) 
 5740      keep_cfunc_refs(c_AppEventCb, py_AppEventCb) 
 5741      keep_elem_refs(userdata, puserdata) 
 5742      retval = _fl_set_event_callback(c_AppEventCb, puserdata) 
 5743      return retval 
 5744   
 5745   
 5746 -def fl_set_idle_callback(py_AppEventCb, userdata): 
 5747      """ fl_set_idle_callback(py_AppEventCb, userdata) -> event callback func. 
 5748      """ 
 5749   
 5750      _fl_set_idle_callback = cfuncproto( 
 5751              load_so_libforms(), "fl_set_idle_callback", 
 5752              FL_APPEVENT_CB, [FL_APPEVENT_CB, cty.c_void_p], 
 5753              """FL_APPEVENT_CB fl_set_idle_callback(FL_APPEVENT_CB callback, 
 5754                 void * user_data) 
 5755              """) 
 5756      c_AppEventCb = FL_APPEVENT_CB(py_AppEventCb) 
 5757      puserdata = cty.cast(userdata, cty.c_void_p) 
 5758      keep_cfunc_refs(c_AppEventCb, py_AppEventCb) 
 5759      keep_elem_refs(userdata, puserdata) 
 5760      retval = _fl_set_idle_callback(c_AppEventCb, puserdata) 
 5761      return retval 
 5762   
 5763   
 5764 -def fl_addto_selected_xevent(win, mask): 
 5765      """ fl_addto_selected_xevent(win, mask) -> num. 
 5766      """ 
 5767   
 5768      _fl_addto_selected_xevent = cfuncproto( 
 5769              load_so_libforms(), "fl_addto_selected_xevent", 
 5770              cty.c_long, [Window, cty.c_long], 
 5771              """long int fl_addto_selected_xevent(Window win, long int mask) 
 5772              """) 
 5773      ulwin = convert_to_Window(win) 
 5774      lmask = convert_to_long(mask) 
 5775      keep_elem_refs(win, mask, ulwin, lmask) 
 5776      retval = _fl_addto_selected_xevent(ulwin, lmask) 
 5777      return retval 
 5778   
 5779   
 5780 -def fl_remove_selected_xevent(win, mask): 
 5781      """ fl_remove_selected_xevent(win, mask) -> num. 
 5782      """ 
 5783   
 5784      _fl_remove_selected_xevent = cfuncproto( 
 5785              load_so_libforms(), "fl_remove_selected_xevent", 
 5786              cty.c_long, [Window, cty.c_long], 
 5787              """)long int fl_remove_selected_xevent(Window win, long int mask) 
 5788              """) 
 5789      ulwin = convert_to_Window(win) 
 5790      lmask = convert_to_long(mask) 
 5791      keep_elem_refs(win, mask, ulwin, lmask) 
 5792      retval = _fl_remove_selected_xevent(ulwin, lmask) 
 5793      return retval 
 5794   
 5795   
 5796  fl_add_selected_xevent = fl_addto_selected_xevent 
 5797   
 5798   
 5799 -def fl_set_idle_delta(delta): 
 5800      """ fl_set_idle_delta(delta) 
 5801      """ 
 5802   
 5803      _fl_set_idle_delta = cfuncproto( 
 5804              load_so_libforms(), "fl_set_idle_delta", 
 5805              None, [cty.c_long], 
 5806              """void fl_set_idle_delta(long int delta) 
 5807              """) 
 5808      ldelta = convert_to_long(delta) 
 5809      keep_elem_refs(delta, ldelta) 
 5810      _fl_set_idle_delta(ldelta) 
 5811   
 5812   
 5813 -def fl_add_event_callback(win, ev, py_AppEventCb, userdata): 
 5814      """ 
 5815          fl_add_event_callback(win, ev, py_AppEventCb, userdata) -> event callback 
 5816   
 5817          Adds an event handler for a window. 
 5818   
 5819          @param win : window id to add event handler to 
 5820          @param ev : event number 
 5821          @param py_AppEventCb : python function for handling event, fn(pXevent, 
 5822             ptr_void) -> num 
 5823          @param userdata : user data argument 
 5824      """ 
 5825   
 5826      _fl_add_event_callback = cfuncproto( 
 5827              load_so_libforms(), "fl_add_event_callback", 
 5828              FL_APPEVENT_CB, [Window, cty.c_int, FL_APPEVENT_CB, cty.c_void_p], 
 5829              """FL_APPEVENT_CB fl_add_event_callback(Window win, int ev, 
 5830                 FL_APPEVENT_CB wincb, void * user_data) 
 5831              """) 
 5832      ulwin = convert_to_Window(win) 
 5833      iev = convert_to_int(ev) 
 5834      c_AppEventCb = FL_APPEVENT_CB(py_AppEventCb) 
 5835      puserdata = cty.cast(userdata, cty.c_void_p) 
 5836      keep_cfunc_refs(c_AppEventCb, py_AppEventCb) 
 5837      keep_elem_refs(win, ev, userdata, ulwin, iev, puserdata) 
 5838      retval = _fl_add_event_callback(ulwin, iev, c_AppEventCb, puserdata) 
 5839      return retval 
 5840   
 5841   
 5842 -def fl_remove_event_callback(win, ev): 
 5843      """ 
 5844          fl_remove_event_callback(win, ev) 
 5845   
 5846          Removes one or all event callbacks for a window. May be called 
 5847          with for a window for which no event callbacks have been set. 
 5848   
 5849          @param win : window id 
 5850          @param ev : evnet number 
 5851      """ 
 5852   
 5853      _fl_remove_event_callback = cfuncproto( 
 5854              load_so_libforms(), "fl_remove_event_callback", 
 5855              None, [Window, cty.c_int], 
 5856              """void fl_remove_event_callback(Window win, int ev) 
 5857              """) 
 5858      ulwin = convert_to_Window(win) 
 5859      iev = convert_to_int(ev) 
 5860      keep_elem_refs(win, ev, ulwin, iev) 
 5861      _fl_remove_event_callback(ulwin, iev) 
 5862   
 5863   
 5864 -def fl_activate_event_callbacks(win): 
 5865      """ fl_activate_event_callbacks(win) 
 5866   
 5867          @param win : window whose events are referred to 
 5868      """ 
 5869   
 5870      _fl_activate_event_callbacks = cfuncproto( 
 5871              load_so_libforms(), "fl_activate_event_callbacks", 
 5872              None, [Window], 
 5873              """void fl_activate_event_callbacks(Window win) 
 5874              """) 
 5875      ulwin = convert_to_Window(win) 
 5876      keep_elem_refs(win, ulwin) 
 5877      _fl_activate_event_callbacks(ulwin) 
 5878   
 5879   
 5880 -def fl_print_xevent_name(where, pXEvent): 
 5881      """ fl_print_xevent_name(where, pXEvent) -> pXEvent 
 5882      """ 
 5883   
 5884      _fl_print_xevent_name = cfuncproto( 
 5885              load_so_libforms(), "fl_print_xevent_name", 
 5886              cty.POINTER(XEvent), [STRING, cty.POINTER(XEvent)], 
 5887              """XEvent * fl_print_xevent_name(const char * where, 
 5888                 const Xevent * xev) 
 5889              """) 
 5890      swhere = convert_to_string(where) 
 5891      keep_elem_refs(where, pXEvent, swhere) 
 5892      retval = _fl_print_xevent_name(swhere, pXEvent) 
 5893      return retval 
 5894   
 5895   
 5896 -def fl_XFlush(): 
 5897      """ 
 5898           fl_XFlush() 
 5899   
 5900           Convenience replacement for XFlush() 
 5901      """ 
 5902   
 5903      _fl_XFlush = cfuncproto( 
 5904              load_so_libforms(), "fl_XFlush", 
 5905              None, [], 
 5906              """void fl_XFlush(void) 
 5907              """) 
 5908      _fl_XFlush() 
 5909   
 5910   
 5911 -def metakey_down(mask): 
 5912      return (mask & Mod1Mask) 
 5913   
 5914   
 5915 -def shiftkey_down(mask): 
 5916      return (mask & ShiftMask) 
 5917   
 5918   
 5919 -def controlkey_down(mask): 
 5920      return (mask & ControlMask) 
 5921   
 5922   
 5923 -def button_down(mask): 
 5924      if (mask & Button1Mask) or (mask & Button2Mask) or \ 
 5925       (mask & Button3Mask) or (mask & Button4Mask) or \ 
 5926       (mask & Button5Mask): 
 5927          return True 
 5928      else: 
 5929          return False 
 5930   
 5931   
 5932  # Resources 
 5933   
 5934 -def fl_initialize(lsysargv, sysargv, appclass, appopt, nappopt): 
 5935      """ fl_initialize(numargs, args, applclass, apploptions, numapplopts) -> pDisplay 
 5936      """ 
 5937   
 5938      _fl_initialize = cfuncproto( 
 5939              load_so_libforms(), "fl_initialize", 
 5940              cty.POINTER(Display), [cty.POINTER(cty.c_int), 
 5941              cty.POINTER(STRING), STRING, cty.POINTER(XrmOptionDescRec), 
 5942              cty.c_int], 
 5943              """Display * fl_initialize(int * na, char * * arg, 
 5944                 const char * appclass, FL_CMD_OPT * appopt, int nappopt) 
 5945              """) 
 5946      verify_version_compatibility()      # verify if installed XForms 
 5947                                          # is compatible with this one 
 5948      lsysargv = 1 
 5949      cliargs_nr = cty.c_int(lsysargv)               #1 
 5950      cliargs_nr_p = cty.byref(cliargs_nr) 
 5951      argum = "".join(sysargv) 
 5952      scliargs = convert_to_string(argum)            # " " 
 5953      sappclass = convert_to_string(appclass) 
 5954      structopts = cty.POINTER(FL_CMD_OPT)() 
 5955      keep_elem_refs(cliargs_nr_p, scliargs, appclass, sappclass, structopts, 
 5956                     nappopt) 
 5957      retval = _fl_initialize(cliargs_nr_p, scliargs, sappclass, structopts, 
 5958                              nappopt) 
 5959      return retval 
 5960   
 5961   
 5962 -def fl_finish(): 
 5963      """ fl_finish() 
 5964      """ 
 5965   
 5966      _fl_finish = cfuncproto( 
 5967              load_so_libforms(), "fl_finish", 
 5968              None, [], 
 5969              """void fl_finish() 
 5970              """) 
 5971      _fl_finish() 
 5972   
 5973   
 5974 -def fl_get_resource(rname, cname, dtype, defval, val, size): 
 5975      """ fl_get_resource(rname, cname, dtype, defval, val, size) -> string 
 5976      """ 
 5977   
 5978      _fl_get_resource = cfuncproto( 
 5979              load_so_libforms(), "fl_get_resource", 
 5980              STRING, [STRING, STRING, FL_RTYPE, STRING, cty.c_void_p, 
 5981              cty.c_int], 
 5982              """const char * fl_get_resource(const char * rname, 
 5983                 const char * cname, FL_RTYPE dtype, const char * defval, 
 5984                 void * val, int size) 
 5985              """) 
 5986      srname = convert_to_string(rname) 
 5987      scname = convert_to_string(cname) 
 5988      idtype = convert_to_int(dtype) 
 5989      sdefval = convert_to_string(defval) 
 5990      pval = cty.cast(val, cty.c_void_p) 
 5991      isize = convert_to_int(size) 
 5992      keep_elem_refs(rname, cname, dtype, defval, val, size, srname, scname, 
 5993                     idtype, sdefval, pval, isize) 
 5994      retval = _fl_get_resource(srname, scname, idtype, sdefval, pval, isize) 
 5995      return retval 
 5996   
 5997   
 5998 -def fl_set_resource(resstr, val): 
 5999      """ fl_set_resource(resstr, val) 
 6000   
 6001          @param resstr : resource name 
 6002          @param val : new string value for resource 
 6003      """ 
 6004   
 6005      _fl_set_resource = cfuncproto( 
 6006              load_so_libforms(), "fl_set_resource", 
 6007              None, [STRING, STRING], 
 6008              """void fl_set_resource(const char * str, const char * val) 
 6009              """) 
 6010      sresstr = convert_to_string(resstr) 
 6011      sval = convert_to_string(val) 
 6012      keep_elem_refs(resstr, val, sresstr, sval) 
 6013      _fl_set_resource(sresstr, sval) 
 6014   
 6015   
 6016 -def fl_get_app_resources(pResource, n): 
 6017      """ fl_get_app_resources(pResource, n) 
 6018      """ 
 6019   
 6020      _fl_get_app_resources = cfuncproto( 
 6021              load_so_libforms(), "fl_get_app_resources", 
 6022              None, [cty.POINTER(FL_RESOURCE), cty.c_int], 
 6023              """void fl_get_app_resources(FL_RESOURCE * appresource, int n) 
 6024              """) 
 6025      inum = convert_to_int(n) 
 6026      keep_elem_refs(pResource, n, inum) 
 6027      _fl_get_app_resources(pResource, inum) 
 6028   
 6029   
 6030 -def fl_set_graphics_mode(mode, doublebuf): 
 6031      """ fl_set_graphics_mode(mode, doublebuf) 
 6032      """ 
 6033   
 6034      _fl_set_graphics_mode = cfuncproto( 
 6035              load_so_libforms(), "fl_set_graphics_mode", 
 6036              None, [cty.c_int, cty.c_int], 
 6037              """void fl_set_graphics_mode(int mode, int doublebuf) 
 6038              """) 
 6039      imode = convert_to_int(mode) 
 6040      idoublebuf = convert_to_int(doublebuf) 
 6041      keep_elem_refs(mode, doublebuf, imode, idoublebuf) 
 6042      _fl_set_graphics_mode(imode, idoublebuf) 
 6043   
 6044   
 6045 -def fl_set_visualID(idnum): 
 6046      """ fl_set_visualID(idnum) 
 6047      """ 
 6048   
 6049      _fl_set_visualID = cfuncproto( 
 6050              load_so_libforms(), "fl_set_visualID", 
 6051              None, [cty.c_long], 
 6052              """void fl_set_visualID(long int id) 
 6053              """) 
 6054      lidnum = convert_to_long(idnum) 
 6055      keep_elem_refs(idnum, lidnum) 
 6056      _fl_set_visualID(lidnum) 
 6057   
 6058   
 6059 -def fl_keysym_pressed(keysym): 
 6060      """ fl_keysym_pressed(keysym) -> num. 
 6061      """ 
 6062   
 6063      _fl_keysym_pressed = cfuncproto( 
 6064              load_so_libforms(), "fl_keysym_pressed", 
 6065              cty.c_int, [KeySym], 
 6066              """int fl_keysym_pressed(KeySym k) 
 6067              """) 
 6068      ulkeysym = convert_to_ulong(keysym) 
 6069      keep_elem_refs(keysym, ulkeysym) 
 6070      retval = _fl_keysym_pressed(ulkeysym) 
 6071      return retval 
 6072   
 6073   
 6074  fl_keypressed = fl_keysym_pressed 
 6075   
 6076   
 6077  # Program default masks 
 6078   
 6079 -def fl_set_defaults(mask, pIopt): 
 6080      """ fl_set_defaults(mask, pIopt) 
 6081      """ 
 6082   
 6083      _fl_set_defaults = cfuncproto( 
 6084              load_so_libforms(), "fl_set_defaults", 
 6085              None, [cty.c_ulong, cty.POINTER(FL_IOPT)], 
 6086              """void fl_set_defaults(long unsigned int mask, FL_IOPT * cntl): 
 6087              """) 
 6088      ulmask = convert_to_ulong(mask) 
 6089      keep_elem_refs(mask, pIopt, ulmask) 
 6090      _fl_set_defaults(ulmask, pIopt) 
 6091   
 6092   
 6093 -def fl_set_tabstop(s): 
 6094      """ fl_set_tabstop(s) 
 6095      """ 
 6096   
 6097      _fl_set_tabstop = cfuncproto( 
 6098              load_so_libforms(), "fl_set_tabstop", 
 6099              None, [STRING], 
 6100              """void fl_set_tabstop(const char * s) 
 6101              """) 
 6102      ss = convert_to_string(s) 
 6103      keep_elem_refs(s, ss) 
 6104      _fl_set_tabstop(ss) 
 6105   
 6106   
 6107 -def fl_get_defaults(pIopt): 
 6108      """ fl_get_defaults(pIopt) 
 6109      """ 
 6110   
 6111      _fl_get_defaults = cfuncproto( 
 6112              load_so_libforms(), "fl_get_defaults", 
 6113              None, [cty.POINTER(FL_IOPT)], 
 6114              """void fl_get_defaults(FL_IOPT * cntl) 
 6115              """) 
 6116      keep_elem_refs(pIopt) 
 6117      _fl_get_defaults(pIopt) 
 6118   
 6119   
 6120 -def fl_get_visual_depth(): 
 6121      """ fl_get_visual_depth() -> depth num. 
 6122      """ 
 6123   
 6124      _fl_get_visual_depth = cfuncproto( 
 6125              load_so_libforms(), "fl_get_visual_depth", 
 6126              cty.c_int, [], 
 6127              """int fl_get_visual_depth() 
 6128              """) 
 6129      retval = _fl_get_visual_depth() 
 6130      return retval 
 6131   
 6132   
 6133 -def fl_vclass_name(n): 
 6134      """ fl_vclass_name(n) -> name string 
 6135      """ 
 6136   
 6137      _fl_vclass_name = cfuncproto( 
 6138              load_so_libforms(), "fl_vclass_name", 
 6139              STRING, [cty.c_int], 
 6140              """const char * fl_vclass_name(int n) 
 6141              """) 
 6142      inum = convert_to_int(n) 
 6143      keep_elem_refs(n, inum) 
 6144      _fl_vclass_name(inum) 
 6145   
 6146   
 6147 -def fl_vclass_val(val): 
 6148      """ fl_vclass_val(val) -> num. 
 6149      """ 
 6150   
 6151      _fl_vclass_val = cfuncproto( 
 6152              load_so_libforms(), "fl_vclass_val", 
 6153              cty.c_int, [STRING], 
 6154              """int fl_vclass_val(const char * v) 
 6155              """) 
 6156      sval = convert_to_string(val) 
 6157      keep_elem_refs(val, sval) 
 6158      retval = _fl_vclass_val(sval) 
 6159      return retval 
 6160   
 6161   
 6162 -def fl_set_ul_property(prop, thickness): 
 6163      """ fl_set_ul_property(prop, thickness) 
 6164      """ 
 6165   
 6166      _fl_set_ul_property = cfuncproto( 
 6167              load_so_libforms(), "fl_set_ul_property", 
 6168              None, [cty.c_int, cty.c_int], 
 6169              """void fl_set_ul_property(int prop, int thickness) 
 6170              """) 
 6171      iprop = convert_to_int(prop) 
 6172      ithickness = convert_to_int(thickness) 
 6173      keep_elem_refs(prop, thickness, iprop, ithickness) 
 6174      _fl_set_ul_property(iprop, ithickness) 
 6175   
 6176   
 6177 -def fl_set_clipping(x, y, w, h): 
 6178      """ fl_set_clipping(x, y, w, h) 
 6179      """ 
 6180   
 6181      _fl_set_clipping = cfuncproto( 
 6182              load_so_libforms(), "fl_set_clipping", 
 6183              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 
 6184              """void fl_set_clipping(FL_Coord x, FL_Coord y, FL_Coord w, 
 6185                 FL_Coord h) 
 6186              """) 
 6187      ix = convert_to_FL_Coord(x) 
 6188      iy = convert_to_FL_Coord(y) 
 6189      iw = convert_to_FL_Coord(w) 
 6190      ih = convert_to_FL_Coord(h) 
 6191      keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 
 6192      _fl_set_clipping(ix, iy, iw, ih) 
 6193   
 6194   
 6195 -def fl_set_gc_clipping(gc, x, y, w, h): 
 6196      """ fl_set_gc_clipping(gc, x, y, w, h) 
 6197      """ 
 6198   
 6199      _fl_set_gc_clipping = cfuncproto( 
 6200              load_so_libforms(), "fl_set_gc_clipping", 
 6201              None, [GC, FL_Coord, FL_Coord, FL_Coord, FL_Coord], 
 6202              """void fl_set_gc_clipping(GC gc, FL_Coord x, FL_Coord y, 
 6203                 FL_Coord w, FL_Coord h) 
 6204              """) 
 6205      ix = convert_to_FL_Coord(x) 
 6206      iy = convert_to_FL_Coord(y) 
 6207      iw = convert_to_FL_Coord(w) 
 6208      ih = convert_to_FL_Coord(h) 
 6209      keep_elem_refs(gc, x, y, w, h, ix, iy, iw, ih) 
 6210      _fl_set_gc_clipping(gc, ix, iy, iw, ih) 
 6211   
 6212   
 6213 -def fl_unset_gc_clipping(gc): 
 6214      """ fl_unset_gc_clipping(gc) 
 6215      """ 
 6216   
 6217      _fl_unset_gc_clipping = cfuncproto( 
 6218              load_so_libforms(), "fl_unset_gc_clipping", 
 6219              None, [GC], 
 6220              """void fl_unset_gc_clipping(GC gc) 
 6221              """) 
 6222      keep_elem_refs(gc) 
 6223      _fl_unset_gc_clipping(gc) 
 6224   
 6225   
 6226 -def fl_set_clippings(pRect, n): 
 6227      """ fl_set_clippings(pRect, n) 
 6228      """ 
 6229   
 6230      _fl_set_clippings = cfuncproto( 
 6231              load_so_libforms(), "fl_set_clippings", 
 6232              None, [cty.POINTER(FL_RECT), cty.c_int], 
 6233              """void fl_set_clippings(FL_RECT * xrect, int n) 
 6234              """) 
 6235      inum = convert_to_int(n) 
 6236      keep_elem_refs(pRect, n, inum) 
 6237      _fl_set_clippings(pRect, inum) 
 6238   
 6239   
 6240 -def fl_unset_clipping(): 
 6241      """ fl_unset_clipping() 
 6242      """ 
 6243   
 6244      _fl_unset_clipping = cfuncproto( 
 6245              load_so_libforms(), "fl_unset_clipping", 
 6246              None, [], 
 6247              """void fl_unset_clipping() 
 6248              """) 
 6249      _fl_unset_clipping() 
 6250   
 6251   
 6252 -def fl_set_text_clipping(x, y, w, h): 
 6253      """ fl_set_text_clipping(x, y, w, h) 
 6254      """ 
 6255   
 6256      _fl_set_text_clipping = cfuncproto( 
 6257              load_so_libforms(), "fl_set_text_clipping", 
 6258              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 
 6259              """void fl_set_text_clipping(FL_Coord x, FL_Coord y, FL_Coord w, 
 6260                 FL_Coord h) 
 6261              """) 
 6262      ix = convert_to_FL_Coord(x) 
 6263      iy = convert_to_FL_Coord(y) 
 6264      iw = convert_to_FL_Coord(w) 
 6265      ih = convert_to_FL_Coord(h) 
 6266      keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 
 6267      _fl_set_text_clipping(ix, iy, iw, ih) 
 6268   
 6269   
 6270 -def fl_unset_text_clipping(): 
 6271      """ fl_unset_text_clipping() 
 6272      """ 
 6273   
 6274      _fl_unset_text_clipping = cfuncproto( 
 6275              load_so_libforms(), "fl_unset_text_clipping", 
 6276              None, [], 
 6277              """void fl_unset_text_clipping() 
 6278              """) 
 6279      _fl_unset_text_clipping() 
 6280   
 6281   
 6282  # How we pack and unpack colors 
 6283   
 6284 -def FL_PCCLAMP(a): 
 6285      if (a > FL_PCMAX): 
 6286          return FL_PCMAX 
 6287      elif (a < 0): 
 6288          return 0 
 6289      else: 
 6290          return a 
 6291   
 6292   
 6293  # If PCBITS is not 8, we need to apply the RGBmask 
 6294   
 6295 -def FL_GETR(packed): 
 6296      return ((packed >> FL_RSHIFT) & FL_RMASK) 
 6297   
 6298  # maybe unused in python? 
 6299 -def FL_GETG(packed): 
 6300      return ((packed) >> FL_GSHIFT) & FL_PCMAX 
 6301   
 6302  # maybe unused in python? 
 6303 -def FL_GETB(packed): 
 6304      return ((packed) >> FL_BSHIFT) & FL_PCMAX 
 6305   
 6306  # maybe unused in python? 
 6307 -def FL_GETA(packed): 
 6308      return ((packed) >> FL_ASHIFT) & FL_PCMAX 
 6309   
 6310  # maybe unused in python? 
 6311 -def FL_PACK3(r, g, b ): 
 6312      return (r<<FL_RSHIFT) | (g<<FL_GSHIFT) | (b<<FL_BSHIFT) 
 6313   
 6314  # maybe unused in python? 
 6315  FL_PACK = FL_PACK3 
 6316   
 6317  # maybe unused in python? 
 6318 -def FL_PACK4(r, g, b, a): 
 6319      return (FL_PACK3(r, g, b) | (a<<FL_ASHIFT)) 
 6320   
 6321  # maybe unused in python? 
 6322 -def FL_UNPACK(p, r, g, b): 
 6323      r = FL_GETR(p) 
 6324      g = FL_GETG(p) 
 6325      b = FL_GETB(p) 
 6326      return r, g, b 
 6327   
 6328  # maybe unused in python? 
 6329  FL_UNPACK3 = FL_UNPACK 
 6330   
 6331  # maybe unused in python? 
 6332 -def FL_UNPACK4(p, r, g, b, a): 
 6333      r, g, b = FL_UNPACK3(p, r, g, b) 
 6334      a = FL_GETA(p) 
 6335      return r, g, b, a 
 6336   
 6337   
 6338 -def fl_popup_add(win, text): 
 6339      """ fl_popup_add(win, text) -> pPopup 
 6340      """ 
 6341   
 6342      _fl_popup_add = cfuncproto( 
 6343              load_so_libforms(), "fl_popup_add", 
 6344              cty.POINTER(FL_POPUP), [Window, STRING], 
 6345              """FL_POPUP * fl_popup_add(Window p1, const char * p2) 
 6346              """) 
 6347      ulwin = convert_to_Window(win) 
 6348      stext = convert_to_string(text) 
 6349      keep_elem_refs(win, text, ulwin, stext) 
 6350      retval = _fl_popup_add(ulwin, stext) 
 6351      return retval 
 6352   
 6353   
 6354 -def fl_popup_add_entries(pPopup, entrytxt): 
 6355      """ fl_popup_add_entries(pPopup, entrytxt) -> pPopupEntry 
 6356      """ 
 6357   
 6358      _fl_popup_add_entries = cfuncproto( 
 6359              load_so_libforms(), "fl_popup_add_entries", 
 6360              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), STRING], 
 6361              """FL_POPUP_ENTRY * fl_popup_add_entries(FL_POPUP * p1, 
 6362                 const char * p2) 
 6363              """) 
 6364      sentrytxt = convert_to_string(entrytxt) 
 6365      keep_elem_refs(pPopup, entrytxt, sentrytxt) 
 6366      retval = _fl_popup_add_entries(pPopup, sentrytxt) 
 6367      return retval 
 6368   
 6369   
 6370 -def fl_popup_insert_entries(pPopup, pPopupEntry, entrytxt): 
 6371      """ fl_popup_insert_entries(pPopup, pPopupEntry, entrytxt) -> pPopupEntry 
 6372      """ 
 6373   
 6374      _fl_popup_insert_entries = cfuncproto( 
 6375              load_so_libforms(), "fl_popup_insert_entries", 
 6376              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), 
 6377              cty.POINTER(FL_POPUP_ENTRY), STRING], 
 6378              """FL_POPUP_ENTRY * fl_popup_insert_entries(FL_POPUP * p1, 
 6379                 FL_POPUP_ENTRY * p2, const char * p3) 
 6380              """) 
 6381      sentrytxt = convert_to_string(entrytxt) 
 6382      keep_elem_refs(pPopup, pPopupEntry, entrytxt, sentrytxt) 
 6383      retval = _fl_popup_insert_entries(pPopup, pPopupEntry, sentrytxt) 
 6384      return retval 
 6385   
 6386   
 6387 -def fl_popup_create(win, text, pPopupItem): 
 6388      """ fl_popup_create(win, text, pPopupItem) -> pPopup 
 6389      """ 
 6390   
 6391      _fl_popup_create = cfuncproto( 
 6392              load_so_libforms(), "fl_popup_create", 
 6393                  cty.POINTER(FL_POPUP), [Window, STRING, 
 6394                  cty.POINTER(FL_POPUP_ITEM)], 
 6395              """FL_POPUP * fl_popup_create(Window p1, const char * p2, 
 6396                 FL_POPUP_ITEM * p3) 
 6397              """) 
 6398      ulwin = convert_to_Window(win) 
 6399      stext = convert_to_string(text) 
 6400      keep_elem_refs(win, text, pPopupItem, ulwin, stext) 
 6401      retval = _fl_popup_create(ulwin, stext, pPopupItem) 
 6402      return retval 
 6403   
 6404   
 6405 -def fl_popup_delete(pPopup): 
 6406      """ fl_popup_delete(pPopup) -> num. 
 6407      """ 
 6408   
 6409      _fl_popup_delete = cfuncproto( 
 6410              load_so_libforms(), "fl_popup_delete", 
 6411              cty.c_int, [cty.POINTER(FL_POPUP)], 
 6412              """int fl_popup_delete(FL_POPUP * p1) 
 6413              """) 
 6414      keep_elem_refs(pPopup) 
 6415      retval = _fl_popup_delete(pPopup) 
 6416      return retval 
 6417   
 6418   
 6419 -def fl_popup_entry_delete(pPopupEntry): 
 6420      """ fl_popup_entry_delete(pPopupEntry) -> num. 
 6421      """ 
 6422   
 6423      _fl_popup_entry_delete = cfuncproto( 
 6424              load_so_libforms(), "fl_popup_entry_delete", 
 6425              cty.c_int, [cty.POINTER(FL_POPUP_ENTRY)], 
 6426              """int fl_popup_entry_delete(FL_POPUP_ENTRY * p1) 
 6427              """) 
 6428      keep_elem_refs(pPopupEntry) 
 6429      retval = _fl_popup_entry_delete(pPopupEntry) 
 6430      return retval 
 6431   
 6432   
 6433 -def fl_popup_do(pPopup): 
 6434      """ fl_popup_do(pPopup) -> pPopupReturn 
 6435      """ 
 6436   
 6437      _fl_popup_do = cfuncproto( 
 6438              load_so_libforms(), "fl_popup_do", 
 6439              cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_POPUP)], 
 6440              """FL_POPUP_RETURN * fl_popup_do(FL_POPUP * p1) 
 6441              """) 
 6442      keep_elem_refs(pPopup) 
 6443      retval = _fl_popup_do(pPopup) 
 6444      return retval 
 6445   
 6446   
 6447 -def fl_popup_set_position(pPopup, x, y): 
 6448      """ 
 6449          fl_popup_set_position(pPopup, x, y) 
 6450   
 6451          Sets position where the popup is supposed to appear (if never called 
 6452          the popup appears at the mouse position) 
 6453   
 6454          @param pPopup : pointer to Popup 
 6455          @param x : horizontal position (upper-left corner) 
 6456          @param y : vertical position (upper-left corner) 
 6457      """ 
 6458   
 6459      _fl_popup_set_position = cfuncproto( 
 6460              load_so_libforms(), "fl_popup_set_position", 
 6461              None, [cty.POINTER(FL_POPUP), cty.c_int, cty.c_int], 
 6462              """void fl_popup_set_position(FL_POPUP * p1, int p2, int p3) 
 6463              """) 
 6464      ix = convert_to_int(x) 
 6465      iy = convert_to_int(y) 
 6466      keep_elem_refs(pPopup, x, y, ix, iy) 
 6467      _fl_popup_set_position(pPopup, ix, iy) 
 6468   
 6469   
 6470 -def fl_popup_get_policy(pPopup): 
 6471      """ 
 6472          fl_popup_get_policy(pPopup) -> num. 
 6473      """ 
 6474   
 6475      _fl_popup_get_policy = cfuncproto( 
 6476              load_so_libforms(), "fl_popup_get_policy", 
 6477              cty.c_int, [cty.POINTER(FL_POPUP)], 
 6478              """int fl_popup_get_policy(FL_POPUP * p1) 
 6479              """) 
 6480      keep_elem_refs(pPopup) 
 6481      retval = _fl_popup_get_policy(pPopup) 
 6482      return retval 
 6483   
 6484   
 6485 -def fl_popup_set_policy(pPopup, policy): 
 6486      """ 
 6487          fl_popup_set_policy(pPopup, policy) -> num. 
 6488   
 6489          Sets policy of handling the popup (i.e. does it get closed when the 
 6490          user releases the mouse button outside an active entry or not?) 
 6491   
 6492          @param pPopup : pointer to Popup 
 6493          @param policy : policy to be set 
 6494      """ 
 6495   
 6496      _fl_popup_set_policy = cfuncproto( 
 6497              load_so_libforms(), "fl_popup_set_policy", 
 6498              cty.c_int, [cty.POINTER(FL_POPUP), cty.c_int], 
 6499              """int fl_popup_set_policy(FL_POPUP * p1, int p2) 
 6500              """) 
 6501      ipolicy = convert_to_int(policy) 
 6502      keep_elem_refs(pPopup, policy, ipolicy) 
 6503      retval = _fl_popup_set_policy(pPopup, ipolicy) 
 6504      return retval 
 6505   
 6506   
 6507  # already defined in xfdata 
 6508  #FL_POPUP_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_POPUP_RETURN)) 
 6509   
 6510 -def fl_popup_set_callback(pPopup, py_PopupCb): 
 6511      """ 
 6512          fl_popup_set_callback(pPopup, py_PopupCb) -> popup callback func. 
 6513      """ 
 6514   
 6515      _fl_popup_set_callback = cfuncproto( 
 6516              load_so_libforms(), "fl_popup_set_callback", 
 6517              FL_POPUP_CB, [cty.POINTER(FL_POPUP), FL_POPUP_CB], 
 6518              """FL_POPUP_CB fl_popup_set_callback(FL_POPUP * p1, 
 6519                 FL_POPUP_CB p2) 
 6520              """) 
 6521      c_PopupCb = FL_POPUP_CB(py_PopupCb) 
 6522      keep_cfunc_refs(c_PopupCb, py_PopupCb) 
 6523      keep_elem_refs(pPopup) 
 6524      retval = _fl_popup_set_callback(pPopup, c_PopupCb) 
 6525      return retval 
 6526   
 6527   
 6528  #def fl_popup_get_title_font(pPopup, style, size)       *API change* 
 6529 -def fl_popup_get_title_font(pPopup): 
 6530      """ 
 6531          fl_popup_get_title_font(pPopup) -> style, size 
 6532      """ 
 6533   
 6534      _fl_popup_get_title_font = cfuncproto( 
 6535              load_so_libforms(), "fl_popup_get_title_font", 
 6536              None, [cty.POINTER(FL_POPUP), cty.POINTER(cty.c_int), 
 6537              cty.POINTER(cty.c_int)], 
 6538              """void fl_popup_get_title_font(FL_POPUP * p1, int * p2, 
 6539                 int * p3) 
 6540              """) 
 6541      style, pstyle = make_int_and_pointer() 
 6542      size, psize = make_int_and_pointer() 
 6543      keep_elem_refs(pPopup, style, size, pstyle, psize) 
 6544      _fl_popup_get_title_font(pPopup, pstyle, psize) 
 6545      return style, size 
 6546   
 6547   
 6548 -def fl_popup_set_title_font(pPopup, style, size): 
 6549      """ 
 6550          fl_popup_set_title_font(pPopup, style, size) 
 6551      """ 
 6552   
 6553      _fl_popup_set_title_font = cfuncproto( 
 6554              load_so_libforms(), "fl_popup_set_title_font", 
 6555              None, [cty.POINTER(FL_POPUP), cty.c_int, cty.c_int], 
 6556              """void fl_popup_set_title_font(FL_POPUP * p1, int p2, int p3) 
 6557              """) 
 6558      istyle = convert_to_int(style) 
 6559      isize = convert_to_int(size) 
 6560      keep_elem_refs(pPopup, style, size, istyle, isize) 
 6561      _fl_popup_set_title_font(pPopup, istyle, isize) 
 6562   
 6563   
 6564  #def fl_popup_entry_get_font(pPopup, style, size)       *API change* 
 6565 -def fl_popup_entry_get_font(pPopup): 
 6566      """ 
 6567          fl_popup_entry_get_font(pPopup) -> style, size 
 6568      """ 
 6569   
 6570      _fl_popup_entry_get_font = cfuncproto( 
 6571              load_so_libforms(), "fl_popup_entry_get_font", 
 6572              None, [cty.POINTER(FL_POPUP), cty.POINTER(cty.c_int), 
 6573              cty.POINTER(cty.c_int)], 
 6574              """void fl_popup_entry_get_font(FL_POPUP * p1, int * p2, int * p3) 
 6575              """) 
 6576      style, pstyle = make_int_and_pointer() 
 6577      size, psize = make_int_and_pointer() 
 6578      keep_elem_refs(pPopup, style, size, pstyle, psize) 
 6579      _fl_popup_entry_get_font(pPopup, pstyle, psize) 
 6580      return style, size 
 6581   
 6582   
 6583 -def fl_popup_entry_set_font(pPopup, style, size): 
 6584      """ 
 6585          fl_popup_entry_set_font(pPopup, style, size) 
 6586   
 6587          Sets the font of a popup entry. 
 6588   
 6589          @param pPopup : pointer to Popup 
 6590          @param style : style of the popup entry 
 6591          @param size : size of the popup entry 
 6592      """ 
 6593   
 6594      _fl_popup_entry_set_font = cfuncproto( 
 6595              load_so_libforms(), "fl_popup_entry_set_font", 
 6596              None, [cty.POINTER(FL_POPUP), cty.c_int, cty.c_int], 
 6597              """void fl_popup_entry_set_font(FL_POPUP * p1, int p2, int p3) 
 6598              """) 
 6599      istyle = convert_to_int(style) 
 6600      isize = convert_to_int(size) 
 6601      keep_elem_refs(pPopup, style, size, istyle, isize) 
 6602      _fl_popup_entry_set_font(pPopup, istyle, isize) 
 6603   
 6604   
 6605 -def fl_popup_get_bw(pPopup): 
 6606      """ 
 6607          fl_popup_get_bw(pPopup) -> borderwidth 
 6608   
 6609          Returns the border width of a popup. 
 6610   
 6611          @param pPopup : pointer to popup 
 6612      """ 
 6613   
 6614      _fl_popup_get_bw = cfuncproto( 
 6615              load_so_libforms(), "fl_popup_get_bw", 
 6616              cty.c_int, [cty.POINTER(FL_POPUP)], 
 6617              """int fl_popup_get_bw(FL_POPUP * p1) 
 6618              """) 
 6619      keep_elem_refs(pPopup) 
 6620      retval = _fl_popup_get_bw(pPopup) 
 6621      return retval 
 6622   
 6623   
 6624 -def fl_popup_set_bw(pPopup, bw): 
 6625      """ 
 6626          fl_popup_set_bw(pPopup, bw) -> num. 
 6627   
 6628          Sets the border width of a popup. 
 6629   
 6630          @param pPopup : pointer to popup 
 6631          @param bw : border width value to be set 
 6632      """ 
 6633   
 6634      _fl_popup_set_bw = cfuncproto( 
 6635              load_so_libforms(), "fl_popup_set_bw", 
 6636              cty.c_int, [cty.POINTER(FL_POPUP), cty.c_int], 
 6637              """int fl_popup_set_bw(FL_POPUP * p1, int p2) 
 6638              """) 
 6639      ibw = convert_to_int(bw) 
 6640      keep_elem_refs(pPopup, bw, ibw) 
 6641      retval = _fl_popup_set_bw(pPopup, ibw) 
 6642      return retval 
 6643   
 6644   
 6645 -def fl_popup_get_color(pPopup, p2): 
 6646      """ 
 6647          fl_popup_get_color(pPopup, p2) -> color 
 6648      """ 
 6649   
 6650      _fl_popup_get_color = cfuncproto( 
 6651              load_so_libforms(), "fl_popup_get_color", 
 6652              FL_COLOR, [cty.POINTER(FL_POPUP), cty.c_int], 
 6653              """FL_COLOR fl_popup_get_color(FL_POPUP * p1, int p2) 
 6654              """) 
 6655      ip2 = convert_to_int(p2) 
 6656      keep_elem_refs(pPopup, p2, ip2) 
 6657      retval = _fl_popup_get_color(pPopup, ip2) 
 6658      return retval 
 6659   
 6660   
 6661 -def fl_popup_set_color(pPopup, p2, colr): 
 6662      """ fl_popup_set_color(pPopup, p2, colr) -> color 
 6663      """ 
 6664   
 6665      _fl_popup_set_color = cfuncproto( 
 6666              load_so_libforms(), "fl_popup_set_color", 
 6667              FL_COLOR, [cty.POINTER(FL_POPUP), cty.c_int, FL_COLOR], 
 6668              """FL_COLOR fl_popup_set_color(FL_POPUP * p1, int p2, FL_COLOR p3) 
 6669              """) 
 6670      check_admitted_listvalues(colr, COLOR_list) 
 6671      ip2 = convert_to_int(p2) 
 6672      ulcolr = convert_to_FL_COLOR(colr) 
 6673      keep_elem_refs(pPopup, p2, colr, ip2, ulcolr) 
 6674      retval = _fl_popup_set_color(pPopup, ip2, ulcolr) 
 6675      return retval 
 6676   
 6677   
 6678 -def fl_popup_set_cursor(pPopup, cursnum): 
 6679      """ 
 6680          fl_popup_set_cursor(pPopup, cursnum) 
 6681      """ 
 6682   
 6683      _fl_popup_set_cursor = cfuncproto( 
 6684              load_so_libforms(), "fl_popup_set_cursor", 
 6685              None, [cty.POINTER(FL_POPUP), cty.c_int], 
 6686              """void fl_popup_set_cursor(FL_POPUP * p1, int p2) 
 6687              """) 
 6688      icursnum = convert_to_int(cursnum) 
 6689      keep_elem_refs(pPopup, cursnum, icursnum) 
 6690      _fl_popup_set_cursor(pPopup, icursnum) 
 6691   
 6692   
 6693 -def fl_popup_get_title(pPopup): 
 6694      """ 
 6695          fl_popup_get_title(pPopup) -> title string 
 6696   
 6697          Returns the title of a popup. 
 6698   
 6699          @param pPopup : pointer to popup 
 6700      """ 
 6701   
 6702      _fl_popup_get_title = cfuncproto( 
 6703              load_so_libforms(), "fl_popup_get_title", 
 6704              STRING, [cty.POINTER(FL_POPUP)], 
 6705              """const char * fl_popup_get_title(FL_POPUP * p1) 
 6706              """) 
 6707      keep_elem_refs(pPopup) 
 6708      retval = _fl_popup_get_title(pPopup) 
 6709      return retval 
 6710   
 6711   
 6712 -def fl_popup_set_title(pPopup, title): 
 6713      """ fl_popup_set_title(pPopup, title) -> popup 
 6714   
 6715          Sets the title of a popup. 
 6716   
 6717          @param pPopup : pointer to popup 
 6718          @param title : title of the popup 
 6719      """ 
 6720   
 6721      _fl_popup_set_title = cfuncproto( 
 6722              load_so_libforms(), "fl_popup_set_title", 
 6723              cty.POINTER(FL_POPUP), [cty.POINTER(FL_POPUP), STRING], 
 6724              """FL_POPUP * fl_popup_set_title(FL_POPUP * p1, const char * p2) 
 6725              """) 
 6726      stitle = convert_to_string(title) 
 6727      keep_elem_refs(pPopup, title, stitle) 
 6728      retval = _fl_popup_set_title(pPopup, stitle) 
 6729      return retval 
 6730   
 6731   
 6732 -def fl_popup_entry_set_callback(pPopupEntry, py_PopupCb): 
 6733      """ fl_popup_entry_set_callback(pPopupEntry, py_PopupCb) -> popup_callback 
 6734      """ 
 6735   
 6736      _fl_popup_entry_set_callback = cfuncproto( 
 6737              load_so_libforms(), "fl_popup_entry_set_callback", 
 6738              FL_POPUP_CB, [cty.POINTER(FL_POPUP_ENTRY), FL_POPUP_CB], 
 6739              """FL_POPUP_CB fl_popup_entry_set_callback(FL_POPUP_ENTRY * p1, 
 6740                 FL_POPUP_CB p2) 
 6741              """) 
 6742      c_PopupCb = FL_POPUP_CB(py_PopupCb) 
 6743      keep_cfunc_refs(c_PopupCb, py_PopupCb) 
 6744      keep_elem_refs(pPopupEntry) 
 6745      retval = _fl_popup_entry_set_callback(pPopupEntry, c_PopupCb) 
 6746      return retval 
 6747   
 6748   
 6749 -def fl_popup_entry_set_enter_callback(pPopupEntry, py_PopupCb): 
 6750      """ fl_popup_entry_set_enter_callback(pPopupEntry, py_PopupCb) -> popup_callback 
 6751      """ 
 6752   
 6753      _fl_popup_entry_set_enter_callback = cfuncproto( 
 6754              load_so_libforms(), "fl_popup_entry_set_enter_callback", 
 6755              FL_POPUP_CB, [cty.POINTER(FL_POPUP_ENTRY), FL_POPUP_CB], 
 6756              """FL_POPUP_CB fl_popup_entry_set_enter_callback( 
 6757                 FL_POPUP_ENTRY * p1, FL_POPUP_CB p2) 
 6758              """) 
 6759      c_PopupCb = FL_POPUP_CB(py_PopupCb) 
 6760      keep_cfunc_refs(c_PopupCb, py_PopupCb) 
 6761      keep_elem_refs(pPopupEntry) 
 6762      retval = _fl_popup_entry_set_enter_callback(pPopupEntry, c_PopupCb) 
 6763      return retval 
 6764   
 6765   
 6766 -def fl_popup_entry_set_leave_callback(pPopupEntry, py_PopupCb): 
 6767      """ fl_popup_entry_set_leave_callback(pPopupEntry, py_PopupCb) -> popup_callback 
 6768      """ 
 6769   
 6770      _fl_popup_entry_set_leave_callback = cfuncproto( 
 6771              load_so_libforms(), "fl_popup_entry_set_leave_callback", 
 6772              FL_POPUP_CB, [cty.POINTER(FL_POPUP_ENTRY), FL_POPUP_CB], 
 6773              """FL_POPUP_CB fl_popup_entry_set_leave_callback( 
 6774                 FL_POPUP_ENTRY * p1, FL_POPUP_CB p2) 
 6775              """) 
 6776      c_PopupCb = FL_POPUP_CB(py_PopupCb) 
 6777      keep_cfunc_refs(c_PopupCb, py_PopupCb) 
 6778      keep_elem_refs(pPopupEntry) 
 6779      retval = _fl_popup_entry_set_leave_callback(pPopupEntry, c_PopupCb) 
 6780      return retval 
 6781   
 6782   
 6783 -def fl_popup_entry_get_state(pPopupEntry): 
 6784      """ fl_popup_entry_get_state(pPopupEntry) -> state num. 
 6785      """ 
 6786   
 6787      _fl_popup_entry_get_state = cfuncproto( 
 6788              load_so_libforms(), "fl_popup_entry_get_state", 
 6789              cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY)], 
 6790              """unsigned int fl_popup_entry_get_state(FL_POPUP_ENTRY * p1) 
 6791              """) 
 6792      keep_elem_refs(pPopupEntry) 
 6793      retval = _fl_popup_entry_get_state(pPopupEntry) 
 6794      return retval 
 6795   
 6796   
 6797 -def fl_popup_entry_set_state(pPopupEntry, state): 
 6798      """ fl_popup_entry_set_state(pPopupEntry, state) -> state num. 
 6799      """ 
 6800   
 6801      _fl_popup_entry_set_state = cfuncproto( 
 6802              load_so_libforms(), "fl_popup_entry_set_state", 
 6803              cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 
 6804              """unsigned int fl_popup_entry_set_state(FL_POPUP_ENTRY * p1, 
 6805                 unsigned int p2) 
 6806              """) 
 6807      uistate = convert_to_uint(state) 
 6808      keep_elem_refs(pPopupEntry, state, uistate) 
 6809      retval = _fl_popup_entry_set_state(pPopupEntry, uistate) 
 6810      return retval 
 6811   
 6812   
 6813 -def fl_popup_entry_clear_state(pPopupEntry, state): 
 6814      """ fl_popup_entry_clear_state(pPopupEntry, state) -> state num. 
 6815      """ 
 6816   
 6817      _fl_popup_entry_clear_state = cfuncproto( 
 6818              load_so_libforms(), "fl_popup_entry_clear_state", 
 6819              cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 
 6820              """unsigned int fl_popup_entry_clear_state(FL_POPUP_ENTRY * p1, 
 6821                 unsigned int p2) 
 6822              """) 
 6823      uistate = convert_to_uint(state) 
 6824      keep_elem_refs(pPopupEntry, state, uistate) 
 6825      retval = _fl_popup_entry_clear_state(pPopupEntry, uistate) 
 6826      return retval 
 6827   
 6828   
 6829 -def fl_popup_entry_raise_state(pPopupEntry, state): 
 6830      """ fl_popup_entry_raise_state(pPopupEntry, state) -> state num. 
 6831      """ 
 6832   
 6833      _fl_popup_entry_raise_state = cfuncproto( 
 6834              load_so_libforms(), "fl_popup_entry_raise_state", 
 6835              cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 
 6836              """unsigned int fl_popup_entry_raise_state(FL_POPUP_ENTRY * p1, 
 6837                 unsigned int p2) 
 6838              """) 
 6839      uistate = convert_to_uint(state) 
 6840      keep_elem_refs(pPopupEntry, state, uistate) 
 6841      retval = _fl_popup_entry_raise_state(pPopupEntry, uistate) 
 6842      return retval 
 6843   
 6844   
 6845 -def fl_popup_entry_toggle_state(pPopupEntry, state): 
 6846      """ fl_popup_entry_toggle_state(pPopupEntry, state) -> num. 
 6847      """ 
 6848   
 6849      _fl_popup_entry_toggle_state = cfuncproto( 
 6850              load_so_libforms(), "fl_popup_entry_toggle_state", 
 6851              cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 
 6852              """unsigned int fl_popup_entry_toggle_state(FL_POPUP_ENTRY * p1, 
 6853                 unsigned int p2) 
 6854              """) 
 6855      uistate = convert_to_uint(state) 
 6856      keep_elem_refs(pPopupEntry, state, uistate) 
 6857      retval = _fl_popup_entry_toggle_state(pPopupEntry, uistate) 
 6858      return retval 
 6859   
 6860   
 6861 -def fl_popup_entry_set_text(pPopupEntry, text): 
 6862      """ fl_popup_entry_set_text(p1, txtstr) -> num. 
 6863      """ 
 6864   
 6865      _fl_popup_entry_set_text = cfuncproto( 
 6866              load_so_libforms(), "fl_popup_entry_set_text", 
 6867              cty.c_int, [cty.POINTER(FL_POPUP_ENTRY), STRING], 
 6868              """int fl_popup_entry_set_text(FL_POPUP_ENTRY * p1, 
 6869                 const char * p2) 
 6870              """) 
 6871      stext = convert_to_string(text) 
 6872      keep_elem_refs(pPopupEntry, text, stext) 
 6873      retval = _fl_popup_entry_set_text(pPopupEntry, stext) 
 6874      return retval 
 6875   
 6876   
 6877 -def fl_popup_entry_set_shortcut(pPopupEntry, textsc): 
 6878      """ fl_popup_entry_set_shortcut(pPopupEntry, textsc) 
 6879      """ 
 6880   
 6881      _fl_popup_entry_set_shortcut = cfuncproto( 
 6882              load_so_libforms(), "fl_popup_entry_set_shortcut", 
 6883              None, [cty.POINTER(FL_POPUP_ENTRY), STRING], 
 6884              """void fl_popup_entry_set_shortcut(FL_POPUP_ENTRY * p1, 
 6885                 const char * p2) 
 6886              """) 
 6887      stextsc = convert_to_string(textsc) 
 6888      keep_elem_refs(pPopupEntry, textsc, stextsc) 
 6889      _fl_popup_entry_set_shortcut(pPopupEntry, stextsc) 
 6890   
 6891   
 6892 -def fl_popup_entry_set_value(pPopupEntry, val): 
 6893      """ fl_popup_entry_set_value(pPopupEntry, p2) -> num. 
 6894      """ 
 6895   
 6896      _fl_popup_entry_set_value = cfuncproto( 
 6897              load_so_libforms(), "fl_popup_entry_set_value", 
 6898              cty.c_long, [cty.POINTER(FL_POPUP_ENTRY), cty.c_long], 
 6899              """long int fl_popup_entry_set_value(FL_POPUP_ENTRY * p1, 
 6900                 long int p2) 
 6901              """) 
 6902      lval = convert_to_long(val) 
 6903      keep_elem_refs(pPopupEntry, val, lval) 
 6904      retval = _fl_popup_entry_set_value(pPopupEntry, lval) 
 6905      return retval 
 6906   
 6907   
 6908 -def fl_popup_entry_set_user_data(pPopupEntry, data): 
 6909      """ fl_popup_entry_set_user_data(pPopupEntry, data) -> ?? 
 6910      """ 
 6911   
 6912      _fl_popup_entry_set_user_data = cfuncproto( 
 6913              load_so_libforms(), "fl_popup_entry_set_user_data", 
 6914              cty.c_void_p, [cty.POINTER(FL_POPUP_ENTRY), cty.c_void_p], 
 6915              """void * fl_popup_entry_set_user_data(FL_POPUP_ENTRY * p1, 
 6916                 void * p2) 
 6917              """) 
 6918      pdata = cty.cast(data, cty.c_void_p) 
 6919      keep_elem_refs(pPopupEntry, data, pdata) 
 6920      retval = _fl_popup_entry_set_user_data(pPopupEntry, pdata) 
 6921      return retval 
 6922   
 6923   
 6924 -def fl_popup_entry_get_by_position(pPopup, numpos): 
 6925      """ fl_popup_entry_get_by_position(pPopup, numpos) -> pPopupEntry 
 6926      """ 
 6927   
 6928      _fl_popup_entry_get_by_position = cfuncproto( 
 6929              load_so_libforms(), "fl_popup_entry_get_by_position", 
 6930              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), cty.c_int], 
 6931              """FL_POPUP_ENTRY * fl_popup_entry_get_by_position(FL_POPUP * p1, 
 6932                 int p2) 
 6933              """) 
 6934      inumpos = convert_to_int(numpos) 
 6935      keep_elem_refs(pPopup, numpos, inumpos) 
 6936      retval = _fl_popup_entry_get_by_position(pPopup, inumpos) 
 6937      return retval 
 6938   
 6939   
 6940 -def fl_popup_entry_get_by_value(pPopup, val): 
 6941      """ fl_popup_entry_get_by_value(pPopup, val) -> pPopupEntry 
 6942      """ 
 6943   
 6944      _fl_popup_entry_get_by_value = cfuncproto( 
 6945              load_so_libforms(), "fl_popup_entry_get_by_value", 
 6946              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), cty.c_long], 
 6947              """FL_POPUP_ENTRY * fl_popup_entry_get_by_value(FL_POPUP * p1, 
 6948                 long int p2) 
 6949              """) 
 6950      lval = convert_to_long(val) 
 6951      keep_elem_refs(pPopup, val, lval) 
 6952      retval = _fl_popup_entry_get_by_value(pPopup, lval) 
 6953      return retval 
 6954   
 6955   
 6956 -def fl_popup_entry_get_by_user_data(pPopup, userdata): 
 6957      """ fl_popup_entry_get_by_user_data(pPopup, userdata) -> pPopupEntry 
 6958      """ 
 6959   
 6960      _fl_popup_entry_get_by_user_data = cfuncproto( 
 6961              load_so_libforms(), "fl_popup_entry_get_by_user_data", 
 6962              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), cty.c_void_p], 
 6963              """FL_POPUP_ENTRY * fl_popup_entry_get_by_user_data(FL_POPUP * p1, 
 6964                 void * p2) 
 6965              """) 
 6966      puserdata = cty.cast(userdata, cty.c_void_p) 
 6967      keep_elem_refs(pPopup, userdata, puserdata) 
 6968      retval = _fl_popup_entry_get_by_user_data(pPopup, puserdata) 
 6969      return retval 
 6970   
 6971   
 6972 -def fl_popup_entry_get_by_text(pPopup, text): 
 6973      """ fl_popup_entry_get_by_text(pPopup, text) -> pPopupEntry 
 6974      """ 
 6975   
 6976      _fl_popup_entry_get_by_text = cfuncproto( 
 6977              load_so_libforms(), "fl_popup_entry_get_by_text", 
 6978              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), STRING], 
 6979              """FL_POPUP_ENTRY * fl_popup_entry_get_by_text(FL_POPUP * p1, 
 6980                 const char * p2) 
 6981              """) 
 6982      stext = convert_to_string(text) 
 6983      keep_elem_refs(pPopup, text, stext) 
 6984      retval = _fl_popup_entry_get_by_text(pPopup, stext) 
 6985      return retval 
 6986   
 6987   
 6988 -def fl_popup_entry_get_by_label(pPopup, label): 
 6989      """ fl_popup_entry_get_by_label(pPopup, label) -> pPopupEntry 
 6990      """ 
 6991   
 6992      _fl_popup_entry_get_by_label = cfuncproto( 
 6993              load_so_libforms(), "fl_popup_entry_get_by_label", 
 6994              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), STRING], 
 6995              """FL_POPUP_ENTRY * fl_popup_entry_get_by_label(FL_POPUP * p1, 
 6996                 const char * p2) 
 6997              """) 
 6998      slabel = convert_to_string(label) 
 6999      keep_elem_refs(pPopup, label, slabel) 
 7000      retval = _fl_popup_entry_get_by_label(pPopup, slabel) 
 7001      return retval 
 7002   
 7003   
 7004 -def fl_popup_entry_get_group(pPopupEntry): 
 7005      """ fl_popup_entry_get_group(pPopupEntry) -> num. 
 7006      """ 
 7007   
 7008      _fl_popup_entry_get_group = cfuncproto( 
 7009              load_so_libforms(), "fl_popup_entry_get_group", 
 7010              cty.c_int, [cty.POINTER(FL_POPUP_ENTRY)], 
 7011              """int fl_popup_entry_get_group(FL_POPUP_ENTRY * p1) 
 7012              """) 
 7013      keep_elem_refs(pPopupEntry) 
 7014      retval = _fl_popup_entry_get_group(pPopupEntry) 
 7015      return retval 
 7016   
 7017   
 7018 -def fl_popup_entry_set_group(pPopupEntry, num): 
 7019      """ fl_popup_entry_set_group(pPopupEntry, num) -> num. 
 7020      """ 
 7021   
 7022      _fl_popup_entry_set_group = cfuncproto( 
 7023              load_so_libforms(), "fl_popup_entry_set_group", 
 7024              cty.c_int, [cty.POINTER(FL_POPUP_ENTRY), cty.c_int], 
 7025              """int fl_popup_entry_set_group(FL_POPUP_ENTRY * p1, int p2) 
 7026              """) 
 7027      inum = convert_to_int(num) 
 7028      keep_elem_refs(pPopupEntry, num, inum) 
 7029      retval = _fl_popup_entry_set_group(pPopupEntry, inum) 
 7030      return retval 
 7031   
 7032   
 7033 -def fl_popup_entry_get_subpopup(pPopupEntry): 
 7034      """ fl_popup_entry_get_subpopup(pPopupEntry) -> pPopup 
 7035      """ 
 7036   
 7037      _fl_popup_entry_get_subpopup = cfuncproto( 
 7038              load_so_libforms(), "fl_popup_entry_get_subpopup", 
 7039              cty.POINTER(FL_POPUP), [cty.POINTER(FL_POPUP_ENTRY)], 
 7040              """FL_POPUP * fl_popup_entry_get_subpopup(FL_POPUP_ENTRY * p1) 
 7041              """) 
 7042      keep_elem_refs(pPopupEntry) 
 7043      retval = _fl_popup_entry_get_subpopup(pPopupEntry) 
 7044      return retval 
 7045   
 7046   
 7047 -def fl_popup_entry_set_subpopup(pPopupEntry, pPopup): 
 7048      """ fl_popup_entry_set_subpopup(pPopupEntry, pPopup) -> pPopup 
 7049      """ 
 7050   
 7051      _fl_popup_entry_set_subpopup = cfuncproto( 
 7052              load_so_libforms(), "fl_popup_entry_set_subpopup", 
 7053              cty.POINTER(FL_POPUP), [cty.POINTER(FL_POPUP_ENTRY), 
 7054              cty.POINTER(FL_POPUP)], 
 7055              """FL_POPUP * fl_popup_entry_set_subpopup(FL_POPUP_ENTRY * p1, 
 7056                 FL_POPUP * p2) 
 7057              """) 
 7058      keep_elem_refs(pPopupEntry, pPopup) 
 7059      retval = _fl_popup_entry_set_subpopup(pPopupEntry, pPopup) 
 7060      return retval 
 7061   
 7062   
 7063  #def fl_popup_get_size(pPopup, w, h)       *API change* 
 7064 -def fl_popup_get_size(pPopup): 
 7065      """ fl_popup_get_size(pPopup) -> size num., width, height 
 7066      """ 
 7067   
 7068      _fl_popup_get_size = cfuncproto( 
 7069              load_so_libforms(), "fl_popup_get_size", 
 7070              cty.c_int, [cty.POINTER(FL_POPUP), cty.POINTER(cty.c_uint), 
 7071              cty.POINTER(cty.c_uint)], 
 7072              """int fl_popup_get_size(FL_POPUP * p1, unsigned int * p2, 
 7073                 unsigned int * p3) 
 7074              """) 
 7075      w, pw = make_uint_and_pointer() 
 7076      h, ph = make_uint_and_pointer() 
 7077      keep_elem_refs(pPopup, w, h, pw, ph) 
 7078      retval = _fl_popup_get_size(pPopup, pw, ph) 
 7079      return retval, w, h 
 7080   
 7081   
 7082 -def fl_popup_get_min_width(pPopup): 
 7083      """ fl_popup_get_min_width(pPopup) -> width num. 
 7084      """ 
 7085   
 7086      _fl_popup_get_min_width = cfuncproto( 
 7087              load_so_libforms(), "fl_popup_get_min_width", 
 7088              cty.c_int, [cty.POINTER(FL_POPUP)], 
 7089              """int fl_popup_get_min_width(FL_POPUP * p1) 
 7090              """) 
 7091      keep_elem_refs(pPopup) 
 7092      retval = _fl_popup_get_min_width(pPopup) 
 7093      return retval 
 7094   
 7095   
 7096 -def fl_popup_set_min_width(pPopup, minwidth): 
 7097      """ fl_popup_set_min_width(pPopup, minwidth) -> width num. 
 7098      """ 
 7099   
 7100      _fl_popup_set_min_width = cfuncproto( 
 7101              load_so_libforms(), "fl_popup_set_min_width", 
 7102              cty.c_int, [cty.POINTER(FL_POPUP), cty.c_int], 
 7103              """int fl_popup_set_min_width(FL_POPUP * p1, int p2) 
 7104              """) 
 7105      iminwidth = convert_to_int(minwidth) 
 7106      keep_elem_refs(pPopup, minwidth, iminwidth) 
 7107      retval = _fl_popup_set_min_width(pPopup, iminwidth) 
 7108      return retval 
 7109   
 7110   
 7111   
 7112  ####################### 
 7113  # forms.h (bitmap.h) 
 7114  # Object Class: Bitmap 
 7115  ####################### 
 7116   
 7117   
 7118  # Routines 
 7119   
 7120 -def fl_create_bitmap(bitmaptype, x, y, w, h, label): 
 7121      """ 
 7122          fl_create_bitmap(bitmaptype, x, y, w, h, label) -> pObject 
 7123   
 7124          Creates a bitmap object. 
 7125   
 7126          @param bitmaptype : type of bitmap to create 
 7127          @param x : horizontal position of bitmap (upper-left corner) 
 7128          @param y : vertical position of bitmap (upper-left corner) 
 7129          @param w : width of bitmap in pixels 
 7130          @param h : height of bitmap in pixels 
 7131          @param label : text label of bitmap 
 7132      """ 
 7133   
 7134      _fl_create_bitmap = cfuncproto( 
 7135              load_so_libforms(), "fl_create_bitmap", 
 7136              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7137              FL_Coord, STRING], 
 7138              """FL_OBJECT * fl_create_bitmap(int type, FL_Coord x, FL_Coord y, 
 7139                 FL_Coord w, FL_Coord h, const char * label) 
 7140              """) 
 7141      check_admitted_listvalues(bitmaptype, BITMAPTYPE_list) 
 7142      ibitmaptype = convert_to_int(bitmaptype) 
 7143      ix = convert_to_FL_Coord(x) 
 7144      iy = convert_to_FL_Coord(y) 
 7145      iw = convert_to_FL_Coord(w) 
 7146      ih = convert_to_FL_Coord(h) 
 7147      slabel = convert_to_int(label) 
 7148      keep_elem_refs(bitmaptype, x, y, w, h, label, ibitmaptype, ix, iy, 
 7149                     iw, ih, slabel) 
 7150      retval = _fl_create_bitmap(ibitmaptype, ix, iy, iw, ih, slabel) 
 7151      return retval 
 7152   
 7153   
 7154 -def fl_add_bitmap(bitmaptype, x, y, w, h, label): 
 7155      """ 
 7156          fl_add_bitmap(bitmaptype, x, y, w, h, label) -> pObject 
 7157   
 7158          Adds a bitmap object. 
 7159   
 7160          @param bitmaptype : type of bitmap to be added 
 7161          @param x : horizontal position of bitmap (upper-left corner) 
 7162          @param y : vertical position of bitmap (upper-left corner) 
 7163          @param w : width of bitmap in pixels 
 7164          @param h : height of bitmap in pixels 
 7165          @param label : text label of bitmap 
 7166      """ 
 7167   
 7168      _fl_add_bitmap = cfuncproto( 
 7169              load_so_libforms(), "fl_add_bitmap", 
 7170              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7171              FL_Coord, STRING], 
 7172              """FL_OBJECT * fl_add_bitmap(int type, FL_Coord x, FL_Coord y, 
 7173                 FL_Coord w, FL_Coord h, const char * label) 
 7174              """) 
 7175      check_admitted_listvalues(bitmaptype, BITMAPTYPE_list) 
 7176      ibitmaptype = convert_to_int(bitmaptype) 
 7177      ix = convert_to_FL_Coord(x) 
 7178      iy = convert_to_FL_Coord(y) 
 7179      iw = convert_to_FL_Coord(w) 
 7180      ih = convert_to_FL_Coord(h) 
 7181      slabel = convert_to_string(label) 
 7182      keep_elem_refs(bitmaptype, x, y, w, h, label, ibitmaptype, ix, iy, iw, 
 7183                     ih, slabel) 
 7184      retval = _fl_add_bitmap(ibitmaptype, ix, iy, iw, ih, slabel) 
 7185      return retval 
 7186   
 7187   
 7188 -def fl_set_bitmap_data(pObject, w, h, xbmcontents): 
 7189      """ fl_set_bitmap_data(pObject, w, h, xbmcontents) 
 7190   
 7191          Fills the bitmap with a bitmap. 
 7192   
 7193          @param pObject : pointer to object 
 7194          @param w : width of bitmap in pixels 
 7195          @param h : height of bitmap in pixels 
 7196          @param xbmcontents : bitmap data used for contents in ubytes 
 7197      """ 
 7198   
 7199      _fl_set_bitmap_data = cfuncproto( 
 7200              load_so_libforms(), "fl_set_bitmap_data", 
 7201              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, 
 7202              cty.POINTER(cty.c_ubyte)], 
 7203              """void fl_set_bitmap_data(FL_OBJECT * ob, int w, int h, 
 7204                 unsigned char * data) 
 7205              """) 
 7206      iw = convert_to_int(w) 
 7207      ih = convert_to_int(h) 
 7208      pxbmcontents = cty.cast(xbmcontents, cty.POINTER(cty.c_ubyte)) 
 7209      keep_elem_refs(pObject, w, h, xbmcontents, iw, ih, pxbmcontents) 
 7210      _fl_set_bitmap_data(pObject, iw, ih, pxbmcontents) 
 7211   
 7212   
 7213 -def fl_set_bitmap_file(pObject, fname): 
 7214      """ fl_set_bitmap_file(pObject, fname) 
 7215   
 7216          @param pObject : pointer to object 
 7217          @param fname : name of bitmap file 
 7218      """ 
 7219   
 7220      _fl_set_bitmap_file = cfuncproto( 
 7221              load_so_libforms(), "fl_set_bitmap_file", 
 7222              None, [cty.POINTER(FL_OBJECT), STRING], 
 7223              """void fl_set_bitmap_file(FL_OBJECT * ob, const char * fname) 
 7224              """) 
 7225      sfname = convert_to_string(fname) 
 7226      keep_elem_refs(pObject, fname, sfname) 
 7227      _fl_set_bitmap_file(pObject, sfname) 
 7228   
 7229   
 7230 -def fl_read_bitmapfile(win, filename, w, h, hotx, hoty): 
 7231      """ fl_read_bitmapfile(win, filename, w, h, hotx, hoty) -> pixmap 
 7232      """ 
 7233   
 7234      _fl_read_bitmapfile = cfuncproto( 
 7235              load_so_libforms(), "fl_read_bitmapfile", 
 7236              Pixmap, [Window, STRING, cty.POINTER(cty.c_uint), 
 7237              cty.POINTER(cty.c_uint), cty.POINTER(cty.c_int), 
 7238              cty.POINTER(cty.c_int)], 
 7239              """Pixmap fl_read_bitmapfile(Window win, const char * file, 
 7240                 unsigned int * w, unsigned int * h, int * hotx, int * hoty) 
 7241              """) 
 7242      ulwin = convert_to_Window(win) 
 7243      sfilename = convert_to_string(filename) 
 7244      pw = cty.cast(w, cty.POINTER(cty.c_uint)) 
 7245      ph = cty.cast(h, cty.POINTER(cty.c_uint)) 
 7246      photx = cty.cast(hotx, cty.POINTER(cty.c_int)) 
 7247      photy = cty.cast(hoty, cty.POINTER(cty.c_int)) 
 7248      keep_elem_refs(win, filename, w, h, hotx, hoty, ulwin, sfilename, 
 7249                     pw, ph, photx, photy) 
 7250      retval = _fl_read_bitmapfile(ulwin, sfilename, pw, ph, photx, photy) 
 7251      return retval 
 7252   
 7253   
 7254 -def fl_create_from_bitmapdata(win, data, w, h): 
 7255      """ 
 7256           fl_create_from_bitmapdata(win, data, w, h) -> pixmap 
 7257   
 7258           @param win : window 
 7259           @param data : bitmap data 
 7260           @param w : width of bitmap in pixels 
 7261           @param h : height of bitmap in pixels 
 7262      """ 
 7263   
 7264      _fl_create_from_bitmapdata = cfuncproto( 
 7265              load_so_libforms(), "fl_create_from_bitmapdata", 
 7266              Pixmap, [Window, STRING, cty.c_int, cty.c_int], 
 7267              """Pixmap fl_create_from_bitmapdata(Window win, const 
 7268                 char * data, int width, int height) 
 7269              """) 
 7270      ulwin = convert_to_ulong(win) 
 7271      sdata = convert_to_string(data) 
 7272      iw = convert_to_int(w) 
 7273      ih = convert_to_int(h) 
 7274      keep_elem_refs(win, data, w, h, ulwin, sdata, iw, ih) 
 7275      retval = _fl_create_from_bitmapdata(ulwin, sdata, iw, ih) 
 7276      return retval 
 7277   
 7278   
 7279  # for compatibility 
 7280  fl_set_bitmap_datafile = fl_set_bitmap_file 
 7281   
 7282   
 7283  # PIXMAP stuff 
 7284   
 7285 -def fl_create_pixmap(pixmaptype, x, y, w, h, label): 
 7286      """ fl_create_pixmap(pixmaptype, x, y, w, h, label) -> pObject 
 7287      """ 
 7288   
 7289      _fl_create_pixmap = cfuncproto( 
 7290              load_so_libforms(), "fl_create_pixmap", 
 7291              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7292              FL_Coord, STRING], 
 7293              """FL_OBJECT * fl_create_pixmap(int type, FL_Coord x, FL_Coord y, 
 7294                 FL_Coord w, FL_Coord h, const char * label) 
 7295              """) 
 7296      check_admitted_listvalues(pixmaptype, PIXMAPTYPE_list) 
 7297      ipixmaptype = convert_to_int(pixmaptype) 
 7298      ix = convert_to_FL_Coord(x) 
 7299      iy = convert_to_FL_Coord(y) 
 7300      iw = convert_to_FL_Coord(w) 
 7301      ih = convert_to_FL_Coord(h) 
 7302      slabel = convert_to_string(label) 
 7303      keep_elem_refs(pixmaptype, x, y, w, h, label, ipixmaptype, ix, iy, iw, 
 7304                     ih, slabel) 
 7305      retval = _fl_create_pixmap(ipixmaptype, ix, iy, iw, ih, slabel) 
 7306      return retval 
 7307   
 7308   
 7309 -def fl_add_pixmap(pixmaptype, x, y, w, h, label): 
 7310      """ fl_add_pixmap(pixmaptype, x, y, w, h, label) -> pObject 
 7311      """ 
 7312   
 7313      _fl_add_pixmap = cfuncproto( 
 7314              load_so_libforms(), "fl_add_pixmap", 
 7315              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7316              FL_Coord, STRING], 
 7317              """FL_OBJECT * fl_add_pixmap(int type, FL_Coord x, FL_Coord y, 
 7318                 FL_Coord w, FL_Coord h, const char * label) 
 7319              """) 
 7320      check_admitted_listvalues(pixmaptype, PIXMAPTYPE_list) 
 7321      ipixmaptype = convert_to_int(pixmaptype) 
 7322      ix = convert_to_FL_Coord(x) 
 7323      iy = convert_to_FL_Coord(y) 
 7324      iw = convert_to_FL_Coord(w) 
 7325      ih = convert_to_FL_Coord(h) 
 7326      slabel = convert_to_string(label) 
 7327      keep_elem_refs(pixmaptype, x, y, w, h, label, ipixmaptype, ix, iy, iw, 
 7328                     ih, slabel) 
 7329      retval = _fl_add_pixmap(ipixmaptype, ix, iy, iw, ih, slabel) 
 7330      return retval 
 7331   
 7332   
 7333 -def fl_set_pixmap_data(pObject, bits): 
 7334      """ fl_set_pixmap_data(pObject, bits) 
 7335      """ 
 7336   
 7337      _fl_set_pixmap_data = cfuncproto( 
 7338              load_so_libforms(), "fl_set_pixmap_data", 
 7339              None, [cty.POINTER(FL_OBJECT), cty.POINTER(STRING)], 
 7340              """void fl_set_pixmap_data(FL_OBJECT * ob, char * * bits) 
 7341              """) 
 7342      keep_elem_refs(pObject, bits) 
 7343      _fl_set_pixmap_data(pObject, bits) 
 7344   
 7345   
 7346 -def fl_set_pixmap_file(pObject, fname): 
 7347      """ fl_set_pixmap_file(pObject, fname) 
 7348   
 7349          @param pObject : pointer to object 
 7350          @param fname : name of the pixmap file 
 7351      """ 
 7352   
 7353      _fl_set_pixmap_file = cfuncproto( 
 7354              load_so_libforms(), "fl_set_pixmap_file", 
 7355              None, [cty.POINTER(FL_OBJECT), STRING], 
 7356              """void fl_set_pixmap_file(FL_OBJECT * ob, const char * fname) 
 7357              """) 
 7358      sfname = convert_to_string(fname) 
 7359      keep_elem_refs(pObject, fname, sfname) 
 7360      _fl_set_pixmap_file(pObject, sfname) 
 7361   
 7362   
 7363 -def fl_set_pixmap_align(pObject, align, xmargin, ymargin): 
 7364      """ fl_set_pixmap_align(pObject, align, xmargin, ymargin) 
 7365      """ 
 7366   
 7367      _fl_set_pixmap_align = cfuncproto( 
 7368              load_so_libforms(), "fl_set_pixmap_align", 
 7369              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, cty.c_int], 
 7370              """void fl_set_pixmap_align(FL_OBJECT * ob, int align, 
 7371                 int xmargin, int ymargin) 
 7372              """) 
 7373      check_admitted_listvalues(align, ALIGN_list) 
 7374      ialign = convert_to_int(align) 
 7375      ixmargin = convert_to_int(xmargin) 
 7376      iymargin = convert_to_int(ymargin) 
 7377      keep_elem_refs(pObject, align, xmargin, ymargin, ialign, ixmargin, 
 7378                     iymargin) 
 7379      _fl_set_pixmap_align(pObject, ialign, ixmargin, iymargin) 
 7380   
 7381   
 7382 -def fl_set_pixmap_pixmap(pObject, idnum, mask): 
 7383      """ fl_set_pixmap_pixmap(pObject, idnum, mask) 
 7384      """ 
 7385   
 7386      _fl_set_pixmap_pixmap = cfuncproto( 
 7387              load_so_libforms(), "fl_set_pixmap_pixmap", 
 7388              None, [cty.POINTER(FL_OBJECT), Pixmap, Pixmap], 
 7389              """void fl_set_pixmap_pixmap(FL_OBJECT * ob, Pixmap id, 
 7390                 Pixmap mask) 
 7391              """) 
 7392      ulidnum = convert_to_ulong(idnum) 
 7393      ulmask = convert_to_ulong(mask) 
 7394      keep_elem_refs(pObject, idnum, mask, ulidnum, ulmask) 
 7395      _fl_set_pixmap_pixmap(pObject, ulidnum, ulmask) 
 7396   
 7397   
 7398 -def fl_set_pixmap_colorcloseness(red, green, blue): 
 7399      """ fl_set_pixmap_colorcloseness(red, green, blue) 
 7400      """ 
 7401   
 7402      _fl_set_pixmap_colorcloseness = cfuncproto( 
 7403              load_so_libforms(), "fl_set_pixmap_colorcloseness", 
 7404              None, [cty.c_int, cty.c_int, cty.c_int], 
 7405              """void fl_set_pixmap_colorcloseness(int red, int green, int blue) 
 7406              """) 
 7407      ired = convert_to_int(red) 
 7408      igreen = convert_to_int(green) 
 7409      iblue = convert_to_int(blue) 
 7410      keep_elem_refs(red, green, blue, ired, igreen, iblue) 
 7411      _fl_set_pixmap_colorcloseness(ired, igreen, iblue) 
 7412   
 7413   
 7414 -def fl_free_pixmap_pixmap(pObject): 
 7415      """ fl_free_pixmap_pixmap(pObject) 
 7416   
 7417          @param pObject : pointer to object 
 7418      """ 
 7419   
 7420      _fl_free_pixmap_pixmap = cfuncproto( 
 7421              load_so_libforms(), "fl_free_pixmap_pixmap", 
 7422              None, [cty.POINTER(FL_OBJECT)], 
 7423              """void fl_free_pixmap_pixmap(FL_OBJECT * ob) 
 7424              """) 
 7425      keep_elem_refs(pObject) 
 7426      _fl_free_pixmap_pixmap(pObject) 
 7427   
 7428   
 7429  #def fl_get_pixmap_pixmap(pObject, p, m)       *API change* 
 7430 -def fl_get_pixmap_pixmap(pObject): 
 7431      """ fl_get_pixmap_pixmap(pObject) -> pixmap, pPixmap, pPixmap_mask 
 7432   
 7433          @param pObject : pointer to object 
 7434      """ 
 7435   
 7436      _fl_get_pixmap_pixmap = cfuncproto( 
 7437              load_so_libforms(), "fl_get_pixmap_pixmap", 
 7438              Pixmap, [cty.POINTER(FL_OBJECT), cty.POINTER(Pixmap), 
 7439              cty.POINTER(Pixmap)], 
 7440              """Pixmap fl_get_pixmap_pixmap(FL_OBJECT * ob, Pixmap * p, 
 7441                 Pixmap * m) 
 7442              """) 
 7443      p, pp = make_ulong_and_pointer() 
 7444      m, pm = make_ulong_and_pointer() 
 7445      keep_elem_refs(pObject, p, m, pp, pm) 
 7446      retval = _fl_get_pixmap_pixmap(pObject, pp, pm) 
 7447      return retval, p, m 
 7448   
 7449   
 7450  #def fl_read_pixmapfile(win, filename, w, h, shape_mask, hotx, hoty, tran)       *API change* 
 7451 -def fl_read_pixmapfile(win, filename, tran): 
 7452      """ fl_read_pixmapfile(win, filename, tran) -> pixmap, w, h, shapemask, hotx, hoty 
 7453      """ 
 7454   
 7455      _fl_read_pixmapfile = cfuncproto( 
 7456              load_so_libforms(), "fl_read_pixmapfile", 
 7457              Pixmap, [Window, STRING, cty.POINTER(cty.c_uint), 
 7458              cty.POINTER(cty.c_uint), cty.POINTER(Pixmap), 
 7459              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), FL_COLOR], 
 7460              """Pixmap fl_read_pixmapfile(Window win, const char * file, 
 7461                 unsigned int * w, unsigned int * h, Pixmap * shape_mask, 
 7462                 int * hotx, int * hoty, FL_COLOR tran) 
 7463              """) 
 7464      check_admitted_listvalues(tran, COLOR_list) 
 7465      ulwin = convert_to_Window(win) 
 7466      sfilename = convert_to_string(filename) 
 7467      ultran = convert_to_FL_COLOR(tran) 
 7468      w, pw = make_uint_and_pointer() 
 7469      h, ph = make_uint_and_pointer() 
 7470      shapemask, pshapemask = make_ulong_and_pointer() 
 7471      hotx, photx = make_int_and_pointer() 
 7472      hoty, photy = make_int_and_pointer() 
 7473      keep_elem_refs(win, filename, w, h, shapemask, hotx, hoty, tran, ulwin, 
 7474                     sfilename, ultran, pw, ph, pshapemask, photx, photy) 
 7475      retval = _fl_read_pixmapfile(ulwin, sfilename, pw, ph, pshapemask, \ 
 7476                                   photx, photy, ultran) 
 7477      return retval, w, h, shapemask, hotx, hoty 
 7478   
 7479   
 7480 -def fl_create_from_pixmapdata(win, data, w, h, sm, hotx, hoty, tran): 
 7481      """ fl_create_from_pixmapdata(win, data, w, h, sm, hotx, hoty, tran) -> pixmap 
 7482      """ 
 7483   
 7484      _fl_create_from_pixmapdata = cfuncproto( 
 7485              load_so_libforms(), "fl_create_from_pixmapdata", 
 7486              Pixmap, [Window, cty.POINTER(STRING), cty.POINTER(cty.c_uint), 
 7487              cty.POINTER(cty.c_uint), cty.POINTER(Pixmap), 
 7488              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), FL_COLOR], 
 7489              """Pixmap fl_create_from_pixmapdata(Window win, char * * data, 
 7490              unsigned int * w, unsigned int * h, Pixmap * sm, int * hotx, 
 7491              int * hoty, FL_COLOR tran) 
 7492              """) 
 7493      check_admitted_listvalues(tran, COLOR_list) 
 7494      ulwin = convert_to_Window(win) 
 7495      ultran = convert_to_FL_COLOR(tran) 
 7496      keep_elem_refs(win, data, w, h, sm, hotx, hoty, tran, ulwin, ultran) 
 7497      retval = _fl_create_from_pixmapdata(ulwin, data, w, h, sm, hotx, hoty, 
 7498                                          ultran) 
 7499      return retval 
 7500   
 7501   
 7502 -def fl_free_pixmap(idnum): 
 7503      """ fl_free_pixmap(idnum) 
 7504   
 7505          @param idnum : Pixmap id to be freed 
 7506      """ 
 7507   
 7508      _fl_free_pixmap = cfuncproto( 
 7509              load_so_libforms(), "fl_free_pixmap", 
 7510              None, [Pixmap], 
 7511              """void fl_free_pixmap(Pixmap id) 
 7512              """) 
 7513      ulidnum = convert_to_Pixmap(idnum) 
 7514      keep_elem_refs(idnum, ulidnum) 
 7515      _fl_free_pixmap(ulidnum) 
 7516   
 7517   
 7518  ################## 
 7519  # forms.h (box.h) 
 7520  ################## 
 7521   
 7522 -def fl_create_box(boxtype, x, y, w, h, label): 
 7523      """ 
 7524          fl_create_box(boxtype, x, y, w, h, label) -> pObject 
 7525   
 7526          Creates a box object. 
 7527   
 7528          @param boxtype : type of the box to be created 
 7529          @param x : horizontal position of box (upper-left corner) 
 7530          @param y : vertical position of box (upper-left corner) 
 7531          @param w : width of box in pixel 
 7532          @param h : height of box in pixel 
 7533          @param label : text label of box 
 7534      """ 
 7535   
 7536      _fl_create_box = cfuncproto( 
 7537              load_so_libforms(), "fl_create_box", 
 7538              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7539              FL_Coord, STRING], 
 7540              """FL_OBJECT * fl_create_box(int type, FL_Coord x, FL_Coord y, 
 7541                 FL_Coord w, FL_Coord h, const char * label) 
 7542              """) 
 7543      check_admitted_listvalues(boxtype, BOXTYPE_list) 
 7544      iboxtype = convert_to_int(boxtype) 
 7545      ix = convert_to_FL_Coord(x) 
 7546      iy = convert_to_FL_Coord(y) 
 7547      iw = convert_to_FL_Coord(w) 
 7548      ih = convert_to_FL_Coord(h) 
 7549      slabel = convert_to_string(label) 
 7550      keep_elem_refs(boxtype, x, y, w, h, label, iboxtype, ix, iy, iw, 
 7551                     ih, slabel) 
 7552      retval = _fl_create_box(iboxtype, ix, iy, iw, ih, slabel) 
 7553      return retval 
 7554   
 7555   
 7556 -def fl_add_box(boxtype, x, y, w, h, label): 
 7557      """ 
 7558          fl_add_box(boxtype, x, y, w, h, label) -> pObject 
 7559   
 7560          Adds a box object. 
 7561   
 7562          @param boxtype : type of the box to be added 
 7563          @param x : horizontal position of box (upper-left corner) 
 7564          @param y : vertical position of box (upper-left corner) 
 7565          @param w : width of box in pixel 
 7566          @param h : height of box in pixel 
 7567          @param label : text label of box 
 7568      """ 
 7569   
 7570      _fl_add_box = cfuncproto( 
 7571              load_so_libforms(), "fl_add_box", 
 7572              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7573              FL_Coord, STRING], 
 7574              """FL_OBJECT * fl_add_box(int type, FL_Coord x, FL_Coord y, 
 7575                 FL_Coord w, FL_Coord h, const char * label) 
 7576              """) 
 7577      check_admitted_listvalues(boxtype, BOXTYPE_list) 
 7578      iboxtype = convert_to_int(boxtype) 
 7579      ix = convert_to_FL_Coord(x) 
 7580      iy = convert_to_FL_Coord(y) 
 7581      iw = convert_to_FL_Coord(w) 
 7582      ih = convert_to_FL_Coord(h) 
 7583      slabel = convert_to_string(label) 
 7584      keep_elem_refs(boxtype, x, y, w, h, label, iboxtype, ix, iy, iw, 
 7585                     ih, slabel) 
 7586      retval = _fl_add_box(iboxtype, ix, iy, iw, ih, slabel) 
 7587      return retval 
 7588   
 7589   
 7590   
 7591  ####################### 
 7592  # forms.h (browser.h) 
 7593  # Object class Browser 
 7594  ####################### 
 7595   
 7596  # Routines 
 7597   
 7598 -def fl_create_browser(browsertype, x, y, w, h, label): 
 7599      """ 
 7600          fl_create_browser(browsertype, x, y, w, h, label) -> pObject 
 7601   
 7602          Creates a browser object. 
 7603   
 7604          @param browsertype : type of the browser to be created 
 7605          @param x : horizontal position of browser (upper-left corner) 
 7606          @param y : vertical position of browser (upper-left corner) 
 7607          @param w : width of browser in pixel 
 7608          @param h : height of browser in pixel 
 7609          @param label : text label of browser 
 7610      """ 
 7611   
 7612      _fl_create_browser = cfuncproto( 
 7613              load_so_libforms(), "fl_create_browser", 
 7614              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7615              FL_Coord, STRING], 
 7616              """FL_OBJECT * fl_create_browser(int type, FL_Coord x, FL_Coord y, 
 7617                 FL_Coord w, FL_Coord h, const char * label) 
 7618              """) 
 7619      check_admitted_listvalues(browsertype, BROWSERTYPE_list) 
 7620      ibrowsertype = convert_to_int(browsertype) 
 7621      ix = convert_to_FL_Coord(x) 
 7622      iy = convert_to_FL_Coord(y) 
 7623      iw = convert_to_FL_Coord(w) 
 7624      ih = convert_to_FL_Coord(h) 
 7625      slabel = convert_to_string(label) 
 7626      keep_elem_refs(browsertype, x, y, w, h, label, ibrowsertype, ix, iy, iw, 
 7627                     ih, slabel) 
 7628      retval = _fl_create_browser(ibrowsertype, ix, iy, iw, ih, slabel) 
 7629      return retval 
 7630   
 7631   
 7632 -def fl_add_browser(browsertype, x, y, w, h, label): 
 7633      """ 
 7634          fl_add_browser(browsertype, x, y, w, h, label) -> pObject 
 7635   
 7636          Adds a browser object. 
 7637   
 7638          @param browsertype : type of the browser to be added 
 7639          @param x : horizontal position of browser (upper-left corner) 
 7640          @param y : vertical position of browser (upper-left corner) 
 7641          @param w : width of browser in pixels 
 7642          @param h : height of browser in pixels 
 7643          @param label : text label of browser 
 7644      """ 
 7645   
 7646      _fl_add_browser = cfuncproto( 
 7647              load_so_libforms(), "fl_add_browser", 
 7648              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7649              FL_Coord, STRING], 
 7650              """FL_OBJECT * fl_add_browser(int type, FL_Coord x, FL_Coord y, 
 7651                 FL_Coord w, FL_Coord h, const char * label) 
 7652              """) 
 7653      check_admitted_listvalues(browsertype, BROWSERTYPE_list) 
 7654      ibrowsertype = convert_to_int(browsertype) 
 7655      ix = convert_to_FL_Coord(x) 
 7656      iy = convert_to_FL_Coord(y) 
 7657      iw = convert_to_FL_Coord(w) 
 7658      ih = convert_to_FL_Coord(h) 
 7659      slabel = convert_to_string(label) 
 7660      keep_elem_refs(browsertype, x, y, w, h, label, ibrowsertype, ix, iy, iw, 
 7661                     ih, slabel) 
 7662      retval = _fl_add_browser(ibrowsertype, ix, iy, iw, ih, slabel) 
 7663      return retval 
 7664   
 7665   
 7666 -def fl_clear_browser(pObject): 
 7667      """ 
 7668          fl_clear_browser(pObject) 
 7669   
 7670          Clears browser object's contents. 
 7671   
 7672          @param pObject : poiter to browser object 
 7673      """ 
 7674   
 7675      _fl_clear_browser = cfuncproto( 
 7676              load_so_libforms(), "fl_clear_browser", 
 7677              None, [cty.POINTER(FL_OBJECT)], 
 7678              """void fl_clear_browser(FL_OBJECT * ob) 
 7679              """) 
 7680      keep_elem_refs(pObject) 
 7681      _fl_clear_browser(pObject) 
 7682   
 7683   
 7684 -def fl_add_browser_line(pObject, newtext): 
 7685      """ 
 7686          fl_add_browser_line(pObject, newtext) 
 7687   
 7688          Add a line to a browser object. 
 7689   
 7690          @param pObject : pointer to browser object 
 7691          @param newtext : line of text to be added 
 7692      """ 
 7693   
 7694      _fl_add_browser_line = cfuncproto( 
 7695              load_so_libforms(), "fl_add_browser_line", 
 7696              None, [cty.POINTER(FL_OBJECT), STRING], 
 7697              """void fl_add_browser_line(FL_OBJECT * ob, const char * newtext) 
 7698              """) 
 7699      snewtext = convert_to_string(newtext) 
 7700      keep_elem_refs(pObject, newtext, snewtext) 
 7701      _fl_add_browser_line(pObject, snewtext) 
 7702   
 7703   
 7704 -def fl_addto_browser(pObject, newtext): 
 7705      """ fl_addto_browser(pObject, newtext) 
 7706      """ 
 7707   
 7708      _fl_addto_browser = cfuncproto( 
 7709              load_so_libforms(), "fl_addto_browser", 
 7710              None, [cty.POINTER(FL_OBJECT), STRING], 
 7711              """void fl_addto_browser(FL_OBJECT * ob, const char * newtext) 
 7712              """) 
 7713      snewtext = convert_to_string(newtext) 
 7714      keep_elem_refs(pObject, newtext, snewtext) 
 7715      _fl_addto_browser(pObject, snewtext) 
 7716   
 7717   
 7718 -def fl_addto_browser_chars(pObject, browsertext): 
 7719      """ fl_addto_browser_chars(pObject, browsertext) 
 7720      """ 
 7721   
 7722      _fl_addto_browser_chars = cfuncproto( 
 7723              load_so_libforms(), "fl_addto_browser_chars", 
 7724              None, [cty.POINTER(FL_OBJECT), STRING], 
 7725              """void fl_addto_browser_chars(FL_OBJECT * ob, const char * str) 
 7726              """) 
 7727      sbrowsertext = convert_to_string(browsertext) 
 7728      keep_elem_refs(pObject, browsertext, sbrowsertext) 
 7729      _fl_addto_browser_chars(pObject, sbrowsertext) 
 7730   
 7731   
 7732  fl_append_browser = fl_addto_browser_chars 
 7733   
 7734   
 7735 -def fl_insert_browser_line(pObject, linenumb, newtext): 
 7736      """ fl_insert_browser_line(pObject, linenumb, newtext) 
 7737      """ 
 7738   
 7739      _fl_insert_browser_line = cfuncproto( 
 7740              load_so_libforms(), "fl_insert_browser_line", 
 7741              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
 7742              """void fl_insert_browser_line(FL_OBJECT * ob, int linenumb, 
 7743                 const char * newtext) 
 7744              """) 
 7745      ilinenumb = convert_to_int(linenumb) 
 7746      snewtext = convert_to_string(newtext) 
 7747      keep_elem_refs(pObject, linenumb, newtext, ilinenumb, snewtext) 
 7748      _fl_insert_browser_line(pObject, ilinenumb, snewtext) 
 7749   
 7750   
 7751 -def fl_delete_browser_line(pObject, linenumb): 
 7752      """ fl_delete_browser_line(pObject, linenumb) 
 7753      """ 
 7754   
 7755      _fl_delete_browser_line = cfuncproto( 
 7756              load_so_libforms(), "fl_delete_browser_line", 
 7757              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7758              """void fl_delete_browser_line(FL_OBJECT * ob, int linenumb) 
 7759              """) 
 7760      ilinenumb = convert_to_int(linenumb) 
 7761      keep_elem_refs(pObject, linenumb, ilinenumb) 
 7762      _fl_delete_browser_line(pObject, ilinenumb) 
 7763   
 7764   
 7765 -def fl_replace_browser_line(pObject, linenumb, newtext): 
 7766      """ fl_replace_browser_line(pObject, linenumb, newtext) 
 7767      """ 
 7768   
 7769      _fl_replace_browser_line = cfuncproto( 
 7770              load_so_libforms(), "fl_replace_browser_line", 
 7771              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
 7772              """void fl_replace_browser_line(FL_OBJECT * ob, int linenumb, 
 7773                 const char * newtext) 
 7774              """) 
 7775      ilinenumb = convert_to_int(linenumb) 
 7776      snewtext = convert_to_string(newtext) 
 7777      keep_elem_refs(pObject, linenumb, newtext, ilinenumb, snewtext) 
 7778      _fl_replace_browser_line(pObject, ilinenumb, snewtext) 
 7779   
 7780   
 7781 -def fl_get_browser_line(pObject, linenumb): 
 7782      """ fl_get_browser_line(pObject, linenumb) -> line string 
 7783      """ 
 7784   
 7785      _fl_get_browser_line = cfuncproto( 
 7786              load_so_libforms(), "fl_get_browser_line", 
 7787              STRING, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7788              """const char * fl_get_browser_line(FL_OBJECT * ob, int linenumb) 
 7789              """) 
 7790      ilinenumb = convert_to_int(linenumb) 
 7791      keep_elem_refs(pObject, linenumb, ilinenumb) 
 7792      retval = _fl_get_browser_line(pObject, ilinenumb) 
 7793      return retval 
 7794   
 7795   
 7796 -def fl_load_browser(pObject, filename): 
 7797      """ fl_load_browser(pObject, filename) -> num. 
 7798      """ 
 7799   
 7800      _fl_load_browser = cfuncproto( 
 7801              load_so_libforms(), "fl_load_browser", 
 7802              cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 
 7803              """int fl_load_browser(FL_OBJECT * ob, const char * filename) 
 7804              """) 
 7805      sfilename = convert_to_string(filename) 
 7806      keep_elem_refs(pObject, filename, sfilename) 
 7807      retval = _fl_load_browser(pObject, sfilename) 
 7808      return retval 
 7809   
 7810   
 7811 -def fl_select_browser_line(pObject, line): 
 7812      """ fl_select_browser_line(pObject, line) 
 7813      """ 
 7814   
 7815      _fl_select_browser_line = cfuncproto( 
 7816              load_so_libforms(), "fl_select_browser_line", 
 7817              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7818              """void fl_select_browser_line(FL_OBJECT * ob, int line) 
 7819              """) 
 7820      iline = convert_to_int(line) 
 7821      keep_elem_refs(pObject, line, iline) 
 7822      _fl_select_browser_line(pObject, iline) 
 7823   
 7824   
 7825 -def fl_deselect_browser_line(pObject, line): 
 7826      """ fl_deselect_browser_line(pObject, line) 
 7827      """ 
 7828   
 7829      _fl_deselect_browser_line = cfuncproto( 
 7830              load_so_libforms(), "fl_deselect_browser_line", 
 7831              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7832              """void fl_deselect_browser_line(FL_OBJECT * ob, int line) 
 7833              """) 
 7834      iline = convert_to_int(line) 
 7835      keep_elem_refs(pObject, line, iline) 
 7836      _fl_deselect_browser_line(pObject, iline) 
 7837   
 7838   
 7839 -def fl_deselect_browser(pObject): 
 7840      """ fl_deselect_browser(pObject) 
 7841   
 7842          @param pObject : pointer to object 
 7843      """ 
 7844   
 7845      _fl_deselect_browser = cfuncproto( 
 7846              load_so_libforms(), "fl_deselect_browser", 
 7847              None, [cty.POINTER(FL_OBJECT)], 
 7848              """void fl_deselect_browser(FL_OBJECT * ob) 
 7849              """) 
 7850      keep_elem_refs(pObject) 
 7851      _fl_deselect_browser(pObject) 
 7852   
 7853   
 7854 -def fl_isselected_browser_line(pObject, line): 
 7855      """ fl_isselected_browser_line(pObject, line) -> num. 
 7856      """ 
 7857   
 7858      _fl_isselected_browser_line = cfuncproto( 
 7859              load_so_libforms(), "fl_isselected_browser_line", 
 7860              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7861              """int fl_isselected_browser_line(FL_OBJECT * ob, int line) 
 7862              """) 
 7863      iline = convert_to_int(line) 
 7864      keep_elem_refs(pObject, line, iline) 
 7865      retval = _fl_isselected_browser_line(pObject, iline) 
 7866      return retval 
 7867   
 7868   
 7869 -def fl_get_browser_topline(pObject): 
 7870      """ fl_get_browser_topline(pObject) -> num. 
 7871      """ 
 7872   
 7873      _fl_get_browser_topline = cfuncproto( 
 7874              load_so_libforms(), "fl_get_browser_topline", 
 7875              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 7876              """int fl_get_browser_topline(FL_OBJECT * ob) 
 7877              """) 
 7878      keep_elem_refs(pObject) 
 7879      retval = _fl_get_browser_topline(pObject) 
 7880      return retval 
 7881   
 7882   
 7883 -def fl_get_browser(pObject): 
 7884      """ fl_get_browser(pObject) -> num. 
 7885      """ 
 7886   
 7887      _fl_get_browser = cfuncproto( 
 7888              load_so_libforms(), "fl_get_browser", 
 7889              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 7890              """int fl_get_browser(FL_OBJECT * ob) 
 7891              """) 
 7892      keep_elem_refs(pObject) 
 7893      retval = _fl_get_browser(pObject) 
 7894      return retval 
 7895   
 7896   
 7897 -def fl_get_browser_maxline(pObject): 
 7898      """ fl_get_browser_maxline(pObject) -> line num. 
 7899      """ 
 7900   
 7901      _fl_get_browser_maxline = cfuncproto( 
 7902              load_so_libforms(), "fl_get_browser_maxline", 
 7903              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 7904              """int fl_get_browser_maxline(FL_OBJECT * ob) 
 7905              """) 
 7906      keep_elem_refs(pObject) 
 7907      retval = _fl_get_browser_maxline(pObject) 
 7908      return retval 
 7909   
 7910   
 7911 -def fl_get_browser_screenlines(pObject): 
 7912      """ 
 7913          fl_get_browser_screenlines(pObject) -> lines num. 
 7914   
 7915          Returns an approximation of the number of lines shown in the 
 7916          browser. 
 7917   
 7918          @param pObject : pointer to browser object 
 7919      """ 
 7920   
 7921      _fl_get_browser_screenlines = cfuncproto( 
 7922              load_so_libforms(), "fl_get_browser_screenlines", 
 7923              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 7924              """int fl_get_browser_screenlines(FL_OBJECT * ob) 
 7925              """) 
 7926      keep_elem_refs(pObject) 
 7927      retval = _fl_get_browser_screenlines(pObject) 
 7928      return retval 
 7929   
 7930   
 7931 -def fl_set_browser_topline(pObject, line): 
 7932      """ 
 7933          fl_set_browser_topline(pObject, line) 
 7934   
 7935          Moves a line to the top of the browser. 
 7936   
 7937          @param pObject : pointer to browser object 
 7938          @param line : number of text line to be moved to top 
 7939      """ 
 7940   
 7941      _fl_set_browser_topline = cfuncproto( 
 7942              load_so_libforms(), "fl_set_browser_topline", 
 7943              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7944              """void fl_set_browser_topline(FL_OBJECT * ob, int line) 
 7945              """) 
 7946      iline = convert_to_int(line) 
 7947      keep_elem_refs(pObject, line, iline) 
 7948      _fl_set_browser_topline(pObject, iline) 
 7949   
 7950   
 7951 -def fl_set_browser_bottomline(pObject, line): 
 7952      """ 
 7953          fl_set_browser_bottomline(pObject, line) 
 7954   
 7955          Moves a line to the bottom of the browser. 
 7956   
 7957          @param pObject : pointer to browser object 
 7958          @param line : number of text line to be moved to bottom 
 7959      """ 
 7960   
 7961      _fl_set_browser_bottomline = cfuncproto( 
 7962              load_so_libforms(), "fl_set_browser_bottomline", 
 7963              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7964              """void fl_set_browser_bottomline(FL_OBJECT * ob, int line) 
 7965              """) 
 7966      iline = convert_to_int(line) 
 7967      keep_elem_refs(pObject, line, iline) 
 7968      _fl_set_browser_bottomline(pObject, iline) 
 7969   
 7970   
 7971 -def fl_set_browser_fontsize(pObject, size): 
 7972      """ 
 7973          fl_set_browser_fontsize(pObject, size) 
 7974   
 7975          Sets the font size of a browser object. 
 7976   
 7977          @param pObject : pointer to browser object 
 7978          @param size : font size to be set 
 7979      """ 
 7980   
 7981      _fl_set_browser_fontsize = cfuncproto( 
 7982              load_so_libforms(), "fl_set_browser_fontsize", 
 7983              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7984              """void fl_set_browser_fontsize(FL_OBJECT * ob, int size) 
 7985              """) 
 7986      isize = convert_to_int(size) 
 7987      keep_elem_refs(pObject, size, isize) 
 7988      _fl_set_browser_fontsize(pObject, isize) 
 7989   
 7990   
 7991 -def fl_set_browser_fontstyle(pObject, style): 
 7992      """ 
 7993          fl_set_browser_fontstyle(pObject, style) 
 7994   
 7995          Sets the font style of a browser object. 
 7996   
 7997          @param pObject : pointer to browser object 
 7998          @param style : font style to be set 
 7999      """ 
 8000   
 8001      _fl_set_browser_fontstyle = cfuncproto( 
 8002              load_so_libforms(), "fl_set_browser_fontstyle", 
 8003              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8004              """void fl_set_browser_fontstyle(FL_OBJECT * ob, int style) 
 8005              """) 
 8006      istyle = convert_to_int(style) 
 8007      keep_elem_refs(pObject, style, istyle) 
 8008      _fl_set_browser_fontstyle(pObject, istyle) 
 8009   
 8010   
 8011 -def fl_set_browser_specialkey(pObject, specialkey): 
 8012      """ 
 8013          fl_set_browser_specialkey(pObject, specialkey) 
 8014   
 8015          Sets the escape key used in the text. 
 8016   
 8017          @param pObject : pointer to browser object 
 8018          @param specialkey : escape key to be set 
 8019      """ 
 8020   
 8021      _fl_set_browser_specialkey = cfuncproto( 
 8022              load_so_libforms(), "fl_set_browser_specialkey", 
 8023              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8024              """void fl_set_browser_specialkey(FL_OBJECT * ob, int specialkey) 
 8025              """) 
 8026      ispecialkey = convert_to_int(specialkey) 
 8027      keep_elem_refs(pObject, specialkey, ispecialkey) 
 8028      _fl_set_browser_specialkey(pObject, ispecialkey) 
 8029   
 8030   
 8031 -def fl_set_browser_vscrollbar(pObject, on): 
 8032      """ fl_set_browser_vscrollbar(pObject, on) 
 8033      """ 
 8034   
 8035      _fl_set_browser_vscrollbar = cfuncproto( 
 8036              load_so_libforms(), "fl_set_browser_vscrollbar", 
 8037              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8038              """void fl_set_browser_vscrollbar(FL_OBJECT * ob, int on) 
 8039              """) 
 8040      ion = convert_to_int(on) 
 8041      keep_elem_refs(pObject, on, ion) 
 8042      _fl_set_browser_vscrollbar(pObject, ion) 
 8043   
 8044   
 8045 -def fl_set_browser_hscrollbar(pObject, on): 
 8046      """ fl_set_browser_hscrollbar(pObject, on) 
 8047      """ 
 8048   
 8049      _fl_set_browser_hscrollbar = cfuncproto( 
 8050              load_so_libforms(), "fl_set_browser_hscrollbar", 
 8051              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8052              """void fl_set_browser_hscrollbar(FL_OBJECT * ob, int on) 
 8053              """) 
 8054      ion = convert_to_int(on) 
 8055      keep_elem_refs(pObject, on, ion) 
 8056      _fl_set_browser_hscrollbar(pObject, ion) 
 8057   
 8058   
 8059 -def fl_set_browser_line_selectable(pObject, line, flag): 
 8060      """ fl_set_browser_line_selectable(pObject, line, flag) 
 8061      """ 
 8062   
 8063      _fl_set_browser_line_selectable = cfuncproto( 
 8064              load_so_libforms(), "fl_set_browser_line_selectable", 
 8065              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
 8066              """void fl_set_browser_line_selectable(FL_OBJECT * ob, int line, 
 8067                 int flag) 
 8068              """) 
 8069      iline = convert_to_int(line) 
 8070      iflag = convert_to_int(flag) 
 8071      keep_elem_refs(pObject, line, flag, iline, iflag) 
 8072      _fl_set_browser_line_selectable(pObject, iline, iflag) 
 8073   
 8074   
 8075  #def fl_get_browser_dimension(pObject, x, y, w, h)       *API change* 
 8076 -def fl_get_browser_dimension(pObject): 
 8077      """ 
 8078          fl_get_browser_dimension(pObject) -> hor.xpos, ver.ypos, width, height 
 8079   
 8080          Returns all dimensions of a browser object. 
 8081   
 8082          @param pObject : pointer to browser object 
 8083      """ 
 8084   
 8085      _fl_get_browser_dimension = cfuncproto( 
 8086              load_so_libforms(), "fl_get_browser_dimension", 
 8087              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 
 8088              cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 
 8089              cty.POINTER(FL_Coord)], 
 8090              """void fl_get_browser_dimension(FL_OBJECT * ob, FL_Coord * x, 
 8091                 FL_Coord * y, FL_Coord * w, FL_Coord * h) 
 8092              """) 
 8093      x, px = make_FL_Coord_and_pointer() 
 8094      y, py = make_FL_Coord_and_pointer() 
 8095      w, pw = make_FL_Coord_and_pointer() 
 8096      h, ph = make_FL_Coord_and_pointer() 
 8097      keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 
 8098      _fl_get_browser_dimension(pObject, px, py, pw, ph) 
 8099      return x, y, w, h 
 8100   
 8101   
 8102 -def fl_set_browser_dblclick_callback(pObject, py_CallbackPtr, argum): 
 8103      """ fl_set_browser_dblclick_callback(pObject, py_CallbackPtr, argum) 
 8104      """ 
 8105   
 8106      _fl_set_browser_dblclick_callback = cfuncproto( 
 8107              load_so_libforms(), "fl_set_browser_dblclick_callback", 
 8108              None, [cty.POINTER(FL_OBJECT), FL_CALLBACKPTR, cty.c_long], 
 8109              """void fl_set_browser_dblclick_callback(FL_OBJECT * ob, 
 8110                 FL_CALLBACKPTR cb, long int a) 
 8111              """) 
 8112      largum = convert_to_long(argum) 
 8113      c_CallbackPtr = FL_CALLBACKPTR(py_CallbackPtr) 
 8114      keep_cfunc_refs(c_CallbackPtr, py_CallbackPtr) 
 8115      keep_elem_refs(pObject, argum, largum) 
 8116      _fl_set_browser_dblclick_callback(pObject, c_CallbackPtr, largum) 
 8117   
 8118   
 8119 -def fl_get_browser_xoffset(pObject): 
 8120      """ fl_get_browser_xoffset(pObject) -> coord num. 
 8121   
 8122          @param pObject : pointer to browser object 
 8123      """ 
 8124   
 8125      _fl_get_browser_xoffset = cfuncproto( 
 8126              load_so_libforms(), "fl_get_browser_xoffset", 
 8127              FL_Coord, [cty.POINTER(FL_OBJECT)], 
 8128              """FL_Coord fl_get_browser_xoffset(FL_OBJECT * ob) 
 8129              """) 
 8130      keep_elem_refs(pObject) 
 8131      retval = _fl_get_browser_xoffset(pObject) 
 8132      return retval 
 8133   
 8134   
 8135 -def fl_get_browser_rel_xoffset(pObject): 
 8136      """ fl_get_browser_rel_xoffset(pObject) -> num. 
 8137   
 8138          @param pObject : pointer to browser object 
 8139      """ 
 8140   
 8141      _fl_get_browser_rel_xoffset = cfuncproto( 
 8142              load_so_libforms(), "fl_get_browser_rel_xoffset", 
 8143              cty.c_double, [cty.POINTER(FL_OBJECT)], 
 8144              """double fl_get_browser_rel_xoffset(FL_OBJECT * ob) 
 8145              """) 
 8146      keep_elem_refs(pObject) 
 8147      retval = _fl_get_browser_rel_xoffset(pObject) 
 8148      return retval 
 8149   
 8150   
 8151 -def fl_set_browser_xoffset(pObject, npixels): 
 8152      """ fl_set_browser_xoffset(pObject, npixels) 
 8153      """ 
 8154   
 8155      _fl_set_browser_xoffset = cfuncproto( 
 8156              load_so_libforms(), "fl_set_browser_xoffset", 
 8157              None, [cty.POINTER(FL_OBJECT), FL_Coord], 
 8158              """void fl_set_browser_xoffset(FL_OBJECT * ob, FL_Coord npixels) 
 8159              """) 
 8160      inpixels = convert_to_FL_Coord(npixels) 
 8161      keep_elem_refs(pObject, npixels, inpixels) 
 8162      _fl_set_browser_xoffset(pObject, inpixels) 
 8163   
 8164   
 8165 -def fl_set_browser_rel_xoffset(pObject, val): 
 8166      """ fl_set_browser_rel_xoffset(pObject, val) 
 8167      """ 
 8168   
 8169      _fl_set_browser_rel_xoffset = cfuncproto( 
 8170              load_so_libforms(), "fl_set_browser_rel_xoffset", 
 8171              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
 8172              """void fl_set_browser_rel_xoffset(FL_OBJECT * ob, double val) 
 8173              """) 
 8174      fval = convert_to_double(val) 
 8175      keep_elem_refs(pObject, val, fval) 
 8176      _fl_set_browser_rel_xoffset(pObject, fval) 
 8177   
 8178   
 8179 -def fl_get_browser_yoffset(pObject): 
 8180      """ fl_get_browser_yoffset(pObject) -> coord num. 
 8181      """ 
 8182   
 8183      _fl_get_browser_yoffset = cfuncproto( 
 8184              load_so_libforms(), "fl_get_browser_yoffset", 
 8185              FL_Coord, [cty.POINTER(FL_OBJECT)], 
 8186              """FL_Coord fl_get_browser_yoffset(FL_OBJECT * ob) 
 8187              """) 
 8188      keep_elem_refs(pObject) 
 8189      retval = _fl_get_browser_yoffset(pObject) 
 8190      return retval 
 8191   
 8192   
 8193 -def fl_get_browser_rel_yoffset(pObject): 
 8194      """ fl_get_browser_rel_yoffset(pObject) -> num. 
 8195      """ 
 8196   
 8197      _fl_get_browser_rel_yoffset = cfuncproto( 
 8198              load_so_libforms(), "fl_get_browser_rel_yoffset", 
 8199              cty.c_double, [cty.POINTER(FL_OBJECT)], 
 8200              """double fl_get_browser_rel_yoffset(FL_OBJECT * ob) 
 8201              """) 
 8202      keep_elem_refs(pObject) 
 8203      retval = _fl_get_browser_rel_yoffset(pObject) 
 8204      return retval 
 8205   
 8206   
 8207 -def fl_set_browser_yoffset(pObject, npixels): 
 8208      """ fl_set_browser_yoffset(pObject, npixels) 
 8209      """ 
 8210   
 8211      _fl_set_browser_yoffset = cfuncproto( 
 8212              load_so_libforms(), "fl_set_browser_yoffset", 
 8213              None, [cty.POINTER(FL_OBJECT), FL_Coord], 
 8214              """void fl_set_browser_yoffset(FL_OBJECT * ob, FL_Coord npixels) 
 8215              """) 
 8216      inpixels = convert_to_FL_Coord(npixels) 
 8217      keep_elem_refs(pObject, npixels, inpixels) 
 8218      _fl_set_browser_yoffset(pObject, inpixels) 
 8219   
 8220   
 8221 -def fl_set_browser_rel_yoffset(pObject, val): 
 8222      """ fl_set_browser_rel_yoffset(pObject, val) 
 8223      """ 
 8224   
 8225      _fl_set_browser_rel_yoffset = cfuncproto( 
 8226              load_so_libforms(), "fl_set_browser_rel_yoffset", 
 8227              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
 8228              """void fl_set_browser_rel_yoffset(FL_OBJECT * ob, double val) 
 8229              """) 
 8230      fval = convert_to_double(val) 
 8231      keep_elem_refs(pObject, val, fval) 
 8232      _fl_set_browser_rel_yoffset(pObject, fval) 
 8233   
 8234   
 8235 -def fl_set_browser_scrollbarsize(pObject, hh, vw): 
 8236      """ fl_set_browser_scrollbarsize(pObject, hh, vw) 
 8237      """ 
 8238   
 8239      _fl_set_browser_scrollbarsize = cfuncproto( 
 8240              load_so_libforms(), "fl_set_browser_scrollbarsize", 
 8241              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
 8242              """void fl_set_browser_scrollbarsize(FL_OBJECT * ob, 
 8243                 int hh, int vw) 
 8244              """) 
 8245      ihh = convert_to_int(hh) 
 8246      ivw = convert_to_int(vw) 
 8247      keep_elem_refs(pObject, hh, vw, ihh, ivw) 
 8248      _fl_set_browser_scrollbarsize(pObject, ihh, ivw) 
 8249   
 8250   
 8251 -def fl_show_browser_line(pObject, line): 
 8252      """ 
 8253          fl_show_browser_line(pObject, line) 
 8254   
 8255          Bring a browser line into view. 
 8256   
 8257          @param pObject : pointer to browser object 
 8258          @param line : line to show 
 8259      """ 
 8260   
 8261      _fl_show_browser_line = cfuncproto( 
 8262              load_so_libforms(), "fl_show_browser_line", 
 8263              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8264              """void fl_show_browser_line(FL_OBJECT * ob, int j) 
 8265              """) 
 8266      iline = convert_to_int(line) 
 8267      keep_elem_refs(pObject, line, iline) 
 8268      _fl_show_browser_line(pObject, iline) 
 8269   
 8270   
 8271 -def fl_set_default_browser_maxlinelength(n): 
 8272      """ 
 8273          fl_set_default_browser_maxlinelength(n) -> length num. 
 8274   
 8275          Inactive function. Returns always 0 
 8276   
 8277          @param n : unused parameter 
 8278      """ 
 8279   
 8280      _fl_set_default_browser_maxlinelength = cfuncproto( 
 8281              load_so_libforms(), "fl_set_default_browser_maxlinelength", 
 8282              cty.c_int, [cty.c_int], 
 8283              """int fl_set_default_browser_maxlinelength(int n): 
 8284              """) 
 8285      inum = convert_to_int(n) 
 8286      keep_elem_refs(n, inum) 
 8287      retval = _fl_set_default_browser_maxlinelength(inum) 
 8288      return retval 
 8289   
 8290   
 8291  FL_BROWSER_SCROLL_CALLBACK = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), 
 8292                  cty.c_int, cty.c_void_p) 
 8293   
 8294 -def fl_set_browser_hscroll_callback(pObject, py_BrowserScrollCallback, data): 
 8295      """ 
 8296          fl_set_browser_hscroll_callback(pObject, py_BrowserScrollCallback, 
 8297          data) 
 8298   
 8299          @param pObject : pointer to browser object 
 8300          @param py_BrowserScrollCallback : python function, fn(pObject, num, 
 8301             data) 
 8302          @param data : user data argument 
 8303      """ 
 8304   
 8305      _fl_set_browser_hscroll_callback = cfuncproto( 
 8306              load_so_libforms(), "fl_set_browser_hscroll_callback", 
 8307              None, [cty.POINTER(FL_OBJECT), FL_BROWSER_SCROLL_CALLBACK, 
 8308              cty.c_void_p], 
 8309              """void fl_set_browser_hscroll_callback(FL_OBJECT * ob, 
 8310                 FL_BROWSER_SCROLL_CALLBACK cb, void * data) 
 8311              """) 
 8312      c_BrowserScrollCallback = FL_BROWSER_SCROLL_CALLBACK( \ 
 8313                                  py_BrowserScrollCallback) 
 8314      pdata = cty.cast(data, cty.c_void_p) 
 8315      keep_cfunc_refs(c_BrowserScrollCallback, py_BrowserScrollCallback) 
 8316      keep_elem_refs(pObject, data, pdata) 
 8317      _fl_set_browser_hscroll_callback(pObject, c_BrowserScrollCallback, pdata) 
 8318   
 8319   
 8320 -def fl_set_browser_vscroll_callback(pObject, py_BrowserScrollCallback, data): 
 8321      """ 
 8322          fl_set_browser_vscroll_callback(pObject, py_BrowserScrollCallback, 
 8323          data) 
 8324   
 8325          @param pObject : pointer to browser object 
 8326          @param py_BrowserScrollCallback : python function, fn(pObject, num, 
 8327             data) 
 8328          @param data : user data argument 
 8329      """ 
 8330   
 8331      _fl_set_browser_vscroll_callback = cfuncproto( 
 8332              load_so_libforms(), "fl_set_browser_vscroll_callback", 
 8333              None, [cty.POINTER(FL_OBJECT), FL_BROWSER_SCROLL_CALLBACK, 
 8334              cty.c_void_p], 
 8335              """void fl_set_browser_vscroll_callback(FL_OBJECT * ob, 
 8336                 FL_BROWSER_SCROLL_CALLBACK cb, void * data) 
 8337              """) 
 8338      c_BrowserScrollCallback = FL_BROWSER_SCROLL_CALLBACK( \ 
 8339                                  py_BrowserScrollCallback) 
 8340      pdata = cty.cast(data, cty.c_void_p) 
 8341      keep_cfunc_refs(c_BrowserScrollCallback, py_BrowserScrollCallback) 
 8342      keep_elem_refs(pObject, data, pdata) 
 8343      _fl_set_browser_vscroll_callback(pObject, c_BrowserScrollCallback, pdata) 
 8344   
 8345   
 8346 -def fl_get_browser_line_yoffset(pObject, line): 
 8347      """ fl_get_browser_line_yoffset(pObject, line) -> num. 
 8348      """ 
 8349   
 8350      _fl_get_browser_line_yoffset = cfuncproto( 
 8351              load_so_libforms(), "fl_get_browser_line_yoffset", 
 8352              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8353              """int fl_get_browser_line_yoffset(FL_OBJECT * obj, int line) 
 8354              """) 
 8355      iline = convert_to_int(line) 
 8356      keep_elem_refs(pObject, line, iline) 
 8357      retval = _fl_get_browser_line_yoffset(pObject, iline) 
 8358      return retval 
 8359   
 8360   
 8361 -def fl_get_browser_hscroll_callback(pObject): 
 8362      """ fl_get_browser_hscroll_callback(pObject) -> callback 
 8363      """ 
 8364   
 8365      _fl_get_browser_hscroll_callback = cfuncproto( 
 8366              load_so_libforms(), "fl_get_browser_hscroll_callback", 
 8367              FL_BROWSER_SCROLL_CALLBACK, [cty.POINTER(FL_OBJECT)], 
 8368              """FL_BROWSER_SCROLL_CALLBACK fl_get_browser_hscroll_callback( 
 8369                 FL_OBJECT * ob) 
 8370              """) 
 8371      keep_elem_refs(pObject) 
 8372      retval = _fl_get_browser_hscroll_callback(pObject) 
 8373      return retval 
 8374   
 8375   
 8376 -def fl_get_browser_vscroll_callback(pObject): 
 8377      """ fl_get_browser_vscroll_callback(pObject) -> callback 
 8378      """ 
 8379   
 8380      _fl_get_browser_vscroll_callback = cfuncproto( 
 8381              load_so_libforms(), "fl_get_browser_vscroll_callback", 
 8382              FL_BROWSER_SCROLL_CALLBACK, [cty.POINTER(FL_OBJECT)], 
 8383              """FL_BROWSER_SCROLL_CALLBACK fl_get_browser_vscroll_callback( 
 8384                 FL_OBJECT * ob) 
 8385              """) 
 8386      keep_elem_refs(pObject) 
 8387      retval = _fl_get_browser_vscroll_callback(pObject) 
 8388      return retval 
 8389   
 8390   
 8391   
 8392  ############################################################# 
 8393  # forms.h (button.h) 
 8394  # All Buttons: regular button, light button and round button 
 8395  ############################################################# 
 8396   
 8397  # Routines 
 8398   
 8399 -def fl_create_button(buttontype, x, y, w, h, label): 
 8400      """ fl_create_button(buttontype, x, y, w, h, label) -> pObject 
 8401   
 8402          Creates a button object. 
 8403   
 8404          @param buttontype : type of button object to be created 
 8405          @param x : horizontal position of button (upper-left corner) 
 8406          @param x : vertical position of button (upper-left corner) 
 8407          @param w : width of button in pixels 
 8408          @param h : height of button in pixels 
 8409          @param label : text label of button 
 8410      """ 
 8411   
 8412      _fl_create_button = cfuncproto( 
 8413              load_so_libforms(), "fl_create_button", 
 8414              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8415              FL_Coord, STRING], 
 8416              """FL_OBJECT * fl_create_button(int type, FL_Coord x, FL_Coord y, 
 8417                 FL_Coord w, FL_Coord h, const char * label) 
 8418              """) 
 8419      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8420      ibuttontype = convert_to_int(buttontype) 
 8421      ix = convert_to_FL_Coord(x) 
 8422      iy = convert_to_FL_Coord(y) 
 8423      iw = convert_to_FL_Coord(w) 
 8424      ih = convert_to_FL_Coord(h) 
 8425      slabel = convert_to_string(label) 
 8426      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8427                     ih, slabel) 
 8428      retval = _fl_create_button(ibuttontype, ix, iy, iw, ih, slabel) 
 8429      return retval 
 8430   
 8431   
 8432 -def fl_create_roundbutton(buttontype, x, y, w, h, label): 
 8433      """ 
 8434          fl_create_roundbutton(buttontype, x, y, w, h, label) -> pObject 
 8435   
 8436          @param buttontype : type of button object to be created 
 8437          @param x : horizontal position of button (upper-left corner) 
 8438          @param x : vertical position of button (upper-left corner) 
 8439          @param w : width of button in pixels 
 8440          @param h : height of button in pixels 
 8441          @param label : text label of button 
 8442      """ 
 8443   
 8444      _fl_create_roundbutton = cfuncproto( 
 8445              load_so_libforms(), "fl_create_roundbutton", 
 8446              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8447              FL_Coord, STRING], 
 8448              """FL_OBJECT * fl_create_roundbutton(int type, FL_Coord x, 
 8449                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8450              """) 
 8451      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8452      ibuttontype = convert_to_int(buttontype) 
 8453      ix = convert_to_FL_Coord(x) 
 8454      iy = convert_to_FL_Coord(y) 
 8455      iw = convert_to_FL_Coord(w) 
 8456      ih = convert_to_FL_Coord(h) 
 8457      slabel = convert_to_string(label) 
 8458      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8459                     ih, slabel) 
 8460      retval = _fl_create_roundbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8461      return retval 
 8462   
 8463   
 8464 -def fl_create_round3dbutton(buttontype, x, y, w, h, label): 
 8465      """ 
 8466          fl_create_round3dbutton(buttontype, x, y, w, h, label) -> pObject 
 8467   
 8468          @param buttontype : type of button object to be created 
 8469          @param x : horizontal position of button (upper-left corner) 
 8470          @param x : vertical position of button (upper-left corner) 
 8471          @param w : width of button in pixels 
 8472          @param h : height of button in pixels 
 8473          @param label : text label of button 
 8474      """ 
 8475   
 8476      _fl_create_round3dbutton = cfuncproto( 
 8477              load_so_libforms(), "fl_create_round3dbutton", 
 8478              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8479              FL_Coord, STRING], 
 8480              """FL_OBJECT * fl_create_round3dbutton(int type, FL_Coord x, 
 8481                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8482              """) 
 8483      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8484      ibuttontype = convert_to_int(buttontype) 
 8485      ix = convert_to_FL_Coord(x) 
 8486      iy = convert_to_FL_Coord(y) 
 8487      iw = convert_to_FL_Coord(w) 
 8488      ih = convert_to_FL_Coord(h) 
 8489      slabel = convert_to_string(label) 
 8490      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8491                     ih, slabel) 
 8492      retval = _fl_create_round3dbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8493      return retval 
 8494   
 8495   
 8496 -def fl_create_lightbutton(buttontype, x, y, w, h, label): 
 8497      """ 
 8498          fl_create_lightbutton(buttontype, x, y, w, h, label) -> pObject 
 8499   
 8500          @param buttontype : type of button object to be created 
 8501          @param x : horizontal position of button (upper-left corner) 
 8502          @param x : vertical position of button (upper-left corner) 
 8503          @param w : width of button in pixels 
 8504          @param h : height of button in pixels 
 8505          @param label : text label of button 
 8506      """ 
 8507   
 8508      _fl_create_lightbutton = cfuncproto( 
 8509              load_so_libforms(), "fl_create_lightbutton", 
 8510              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8511              FL_Coord, STRING], 
 8512              """FL_OBJECT * fl_create_lightbutton(int type, FL_Coord x, 
 8513                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8514              """) 
 8515      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8516      ibuttontype = convert_to_int(buttontype) 
 8517      ix = convert_to_FL_Coord(x) 
 8518      iy = convert_to_FL_Coord(y) 
 8519      iw = convert_to_FL_Coord(w) 
 8520      ih = convert_to_FL_Coord(h) 
 8521      slabel = convert_to_string(label) 
 8522      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8523                     ih, slabel) 
 8524      retval = _fl_create_lightbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8525      return retval 
 8526   
 8527   
 8528 -def fl_create_checkbutton(buttontype, x, y, w, h, label): 
 8529      """ 
 8530          fl_create_checkbutton(buttontype, x, y, w, h, label) -> pObject 
 8531   
 8532          Creates a checkbutton object. 
 8533   
 8534          @param buttontype : type of button object to be created 
 8535          @param x : horizontal position of button (upper-left corner) 
 8536          @param x : vertical position of button (upper-left corner) 
 8537          @param w : width of button in pixels 
 8538          @param h : height of button in pixels 
 8539          @param label : text label of button 
 8540      """ 
 8541   
 8542      _fl_create_checkbutton = cfuncproto( 
 8543              load_so_libforms(), "fl_create_checkbutton", 
 8544              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8545              FL_Coord, STRING], 
 8546              """FL_OBJECT * fl_create_checkbutton(int type, FL_Coord x, 
 8547                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8548              """) 
 8549      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8550      ibuttontype = convert_to_int(buttontype) 
 8551      ix = convert_to_FL_Coord(x) 
 8552      iy = convert_to_FL_Coord(y) 
 8553      iw = convert_to_FL_Coord(w) 
 8554      ih = convert_to_FL_Coord(h) 
 8555      slabel = convert_to_string(label) 
 8556      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8557                     ih, slabel) 
 8558      retval = _fl_create_checkbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8559      return retval 
 8560   
 8561   
 8562 -def fl_create_bitmapbutton(buttontype, x, y, w, h, label): 
 8563      """ 
 8564          fl_create_bitmapbutton(buttontype, x, y, w, h, label) -> pObject 
 8565   
 8566          @param buttontype : type of button object to be created 
 8567          @param x : horizontal position of button (upper-left corner) 
 8568          @param x : vertical position of button (upper-left corner) 
 8569          @param w : width of button in pixels 
 8570          @param h : height of button in pixels 
 8571          @param label : text label of button 
 8572      """ 
 8573   
 8574      _fl_create_bitmapbutton = cfuncproto( 
 8575              load_so_libforms(), "fl_create_bitmapbutton", 
 8576              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8577              FL_Coord, STRING], 
 8578              """FL_OBJECT * fl_create_bitmapbutton(int type, FL_Coord x, 
 8579                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8580              """) 
 8581      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8582      ibuttontype = convert_to_int(buttontype) 
 8583      ix = convert_to_FL_Coord(x) 
 8584      iy = convert_to_FL_Coord(y) 
 8585      iw = convert_to_FL_Coord(w) 
 8586      ih = convert_to_FL_Coord(h) 
 8587      slabel = convert_to_string(label) 
 8588      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8589                     ih, slabel) 
 8590      retval = _fl_create_bitmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8591      return retval 
 8592   
 8593   
 8594 -def fl_create_pixmapbutton(buttontype, x, y, w, h, label): 
 8595      """ 
 8596          fl_create_pixmapbutton(buttontype, x, y, w, h, label) -> pObject 
 8597   
 8598          @param buttontype : type of button object to be created 
 8599          @param x : horizontal position of button (upper-left corner) 
 8600          @param x : vertical position of button (upper-left corner) 
 8601          @param w : width of button in pixels 
 8602          @param h : height of button in pixels 
 8603          @param label : text label of button 
 8604      """ 
 8605   
 8606      _fl_create_pixmapbutton = cfuncproto( 
 8607              load_so_libforms(), "fl_create_pixmapbutton", 
 8608              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8609              FL_Coord, STRING], 
 8610              """FL_OBJECT * fl_create_pixmapbutton(int type, FL_Coord x, 
 8611                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8612              """) 
 8613      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8614      ibuttontype = convert_to_int(buttontype) 
 8615      ix = convert_to_FL_Coord(x) 
 8616      iy = convert_to_FL_Coord(y) 
 8617      iw = convert_to_FL_Coord(w) 
 8618      ih = convert_to_FL_Coord(h) 
 8619      slabel = convert_to_string(label) 
 8620      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8621                     ih, slabel) 
 8622      retval = _fl_create_pixmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8623      return retval 
 8624   
 8625   
 8626 -def fl_create_scrollbutton(buttontype, x, y, w, h, label): 
 8627      """ 
 8628          fl_create_scrollbutton(buttontype, x, y, w, h, label) -> pObject 
 8629   
 8630          @param buttontype : type of button object to be created 
 8631          @param x : horizontal position of button (upper-left corner) 
 8632          @param x : vertical position of button (upper-left corner) 
 8633          @param w : width of button in pixels 
 8634          @param h : height of button in pixels 
 8635          @param label : text label of button 
 8636      """ 
 8637   
 8638      _fl_create_scrollbutton = cfuncproto( 
 8639              load_so_libforms(), "fl_create_scrollbutton", 
 8640              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8641              FL_Coord, STRING], 
 8642              """FL_OBJECT * fl_create_scrollbutton(int type, FL_Coord x, 
 8643                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8644              """) 
 8645      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8646      ibuttontype = convert_to_int(buttontype) 
 8647      ix = convert_to_FL_Coord(x) 
 8648      iy = convert_to_FL_Coord(y) 
 8649      iw = convert_to_FL_Coord(w) 
 8650      ih = convert_to_FL_Coord(h) 
 8651      slabel = convert_to_string(label) 
 8652      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8653                     ih, slabel) 
 8654      retval = _fl_create_scrollbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8655      return retval 
 8656   
 8657   
 8658 -def fl_create_labelbutton(buttontype, x, y, w, h, label): 
 8659      """ 
 8660          fl_create_labelbutton(buttontype, x, y, w, h, label) -> pObject 
 8661   
 8662          @param buttontype : type of button object to be created 
 8663          @param x : horizontal position of button (upper-left corner) 
 8664          @param x : vertical position of button (upper-left corner) 
 8665          @param w : width of button in pixels 
 8666          @param h : height of button in pixels 
 8667          @param label : text label of button 
 8668      """ 
 8669   
 8670      _fl_create_labelbutton = cfuncproto( 
 8671              load_so_libforms(), "fl_create_labelbutton", 
 8672              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8673              FL_Coord, STRING], 
 8674              """FL_OBJECT * fl_create_labelbutton(int type, FL_Coord x, 
 8675                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8676              """) 
 8677      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8678      ibuttontype = convert_to_int(buttontype) 
 8679      ix = convert_to_FL_Coord(x) 
 8680      iy = convert_to_FL_Coord(y) 
 8681      iw = convert_to_FL_Coord(w) 
 8682      ih = convert_to_FL_Coord(h) 
 8683      slabel = convert_to_string(label) 
 8684      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8685                     ih, slabel) 
 8686      retval = _fl_create_labelbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8687      return retval 
 8688   
 8689   
 8690 -def fl_add_roundbutton(buttontype, x, y, w, h, label): 
 8691      """ 
 8692          fl_add_roundbutton(buttontype, x, y, w, h, label) -> pObject 
 8693   
 8694          @param buttontype : type of button object to be added 
 8695          @param x : horizontal position of button (upper-left corner) 
 8696          @param x : vertical position of button (upper-left corner) 
 8697          @param w : width of button in pixels 
 8698          @param h : height of button in pixels 
 8699          @param label : text label of button 
 8700      """ 
 8701   
 8702      _fl_add_roundbutton = cfuncproto( 
 8703              load_so_libforms(), "fl_add_roundbutton", 
 8704              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8705              FL_Coord, STRING], 
 8706              """FL_OBJECT * fl_add_roundbutton(int type, FL_Coord x, 
 8707                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8708              """) 
 8709      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8710      ibuttontype = convert_to_int(buttontype) 
 8711      ix = convert_to_FL_Coord(x) 
 8712      iy = convert_to_FL_Coord(y) 
 8713      iw = convert_to_FL_Coord(w) 
 8714      ih = convert_to_FL_Coord(h) 
 8715      slabel = convert_to_string(label) 
 8716      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8717                     ih, slabel) 
 8718      retval = _fl_add_roundbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8719      return retval 
 8720   
 8721   
 8722 -def fl_add_round3dbutton(buttontype, x, y, w, h, label): 
 8723      """ 
 8724          fl_add_round3dbutton(buttontype, x, y, w, h, label) -> pObject 
 8725   
 8726          @param buttontype : type of button object to be added 
 8727          @param x : horizontal position of button (upper-left corner) 
 8728          @param x : vertical position of button (upper-left corner) 
 8729          @param w : width of button in pixels 
 8730          @param h : height of button in pixels 
 8731          @param label : text label of button 
 8732      """ 
 8733   
 8734      _fl_add_round3dbutton = cfuncproto( 
 8735              load_so_libforms(), "fl_add_round3dbutton", 
 8736              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8737              FL_Coord, STRING], 
 8738              """FL_OBJECT * fl_add_round3dbutton(int type, FL_Coord x, 
 8739                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8740              """) 
 8741      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8742      ibuttontype = convert_to_int(buttontype) 
 8743      ix = convert_to_FL_Coord(x) 
 8744      iy = convert_to_FL_Coord(y) 
 8745      iw = convert_to_FL_Coord(w) 
 8746      ih = convert_to_FL_Coord(h) 
 8747      slabel = convert_to_string(label) 
 8748      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8749                     ih, slabel) 
 8750      retval = _fl_add_round3dbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8751      return retval 
 8752   
 8753   
 8754 -def fl_add_lightbutton(buttontype, x, y, w, h, label): 
 8755      """ 
 8756          fl_add_lightbutton(buttontype, x, y, w, h, label) -> pObject 
 8757   
 8758          @param buttontype : type of button object to be added 
 8759          @param x : horizontal position of button (upper-left corner) 
 8760          @param x : vertical position of button (upper-left corner) 
 8761          @param w : width of button in pixels 
 8762          @param h : height of button in pixels 
 8763          @param label : text label of button 
 8764      """ 
 8765   
 8766      _fl_add_lightbutton = cfuncproto( 
 8767              load_so_libforms(), "fl_add_lightbutton", 
 8768              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8769              FL_Coord, STRING], 
 8770              """FL_OBJECT * fl_add_lightbutton(int type, FL_Coord x, FL_Coord y, 
 8771                 FL_Coord w, FL_Coord h, const char * label) 
 8772              """) 
 8773      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8774      ibuttontype = convert_to_int(buttontype) 
 8775      ix = convert_to_FL_Coord(x) 
 8776      iy = convert_to_FL_Coord(y) 
 8777      iw = convert_to_FL_Coord(w) 
 8778      ih = convert_to_FL_Coord(h) 
 8779      slabel = convert_to_string(label) 
 8780      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8781                     ih, slabel) 
 8782      retval = _fl_add_lightbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8783      return retval 
 8784   
 8785   
 8786 -def fl_add_checkbutton(buttontype, x, y, w, h, label): 
 8787      """ 
 8788          fl_add_checkbutton(buttontype, x, y, w, h, label) -> pObject 
 8789   
 8790          Adds a checkbutton object. 
 8791   
 8792          @param buttontype : type of button object to be added 
 8793          @param x : horizontal position of button (upper-left corner) 
 8794          @param x : vertical position of button (upper-left corner) 
 8795          @param w : width of button in pixels 
 8796          @param h : height of button in pixels 
 8797          @param label : text label of button 
 8798      """ 
 8799   
 8800      _fl_add_checkbutton = cfuncproto( 
 8801              load_so_libforms(), "fl_add_checkbutton", 
 8802              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8803              FL_Coord, STRING], 
 8804              """FL_OBJECT * fl_add_checkbutton(int type, FL_Coord x, FL_Coord y, 
 8805                 FL_Coord w, FL_Coord h, const char * label) 
 8806              """) 
 8807      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8808      ibuttontype = convert_to_int(buttontype) 
 8809      ix = convert_to_FL_Coord(x) 
 8810      iy = convert_to_FL_Coord(y) 
 8811      iw = convert_to_FL_Coord(w) 
 8812      ih = convert_to_FL_Coord(h) 
 8813      slabel = convert_to_string(label) 
 8814      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8815                     ih, slabel) 
 8816      retval = _fl_add_checkbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8817      return retval 
 8818   
 8819   
 8820 -def fl_add_button(buttontype, x, y, w, h, label): 
 8821      """ 
 8822          fl_add_button(buttontype, x, y, w, h, label) -> pObject 
 8823   
 8824          Adds a button to the current form. 
 8825   
 8826          @param buttontype : type of button object to be added 
 8827          @param x : horizontal position of button (upper-left corner) 
 8828          @param x : vertical position of button (upper-left corner) 
 8829          @param w : width of button in pixels 
 8830          @param h : height of button in pixels 
 8831          @param label : text label of button 
 8832      """ 
 8833   
 8834      _fl_add_button = cfuncproto( 
 8835              load_so_libforms(), "fl_add_button", 
 8836              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8837              FL_Coord, STRING], 
 8838              """FL_OBJECT * fl_add_button(int type, FL_Coord x, FL_Coord y, 
 8839                 FL_Coord w, FL_Coord h, const char * label) 
 8840              """) 
 8841      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8842      ibuttontype = convert_to_int(buttontype) 
 8843      ix = convert_to_FL_Coord(x) 
 8844      iy = convert_to_FL_Coord(y) 
 8845      iw = convert_to_FL_Coord(w) 
 8846      ih = convert_to_FL_Coord(h) 
 8847      slabel = convert_to_string(label) 
 8848      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8849                     ih, slabel) 
 8850      retval = _fl_add_button(ibuttontype, ix, iy, iw, ih, slabel) 
 8851      return retval 
 8852   
 8853   
 8854 -def fl_add_bitmapbutton(buttontype, x, y, w, h, label): 
 8855      """ 
 8856          fl_add_bitmapbutton(buttontype, x, y, w, h, label) -> pObject 
 8857   
 8858          @param buttontype : type of button object to be added 
 8859          @param x : horizontal position of button (upper-left corner) 
 8860          @param x : vertical position of button (upper-left corner) 
 8861          @param w : width of button in pixels 
 8862          @param h : height of button in pixels 
 8863          @param label : text label of button 
 8864      """ 
 8865   
 8866      _fl_add_bitmapbutton = cfuncproto( 
 8867              load_so_libforms(), "fl_add_bitmapbutton", 
 8868              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8869              FL_Coord, STRING], 
 8870              """FL_OBJECT * fl_add_bitmapbutton(int type, FL_Coord x, 
 8871                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8872              """) 
 8873      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8874      ibuttontype = convert_to_int(buttontype) 
 8875      ix = convert_to_FL_Coord(x) 
 8876      iy = convert_to_FL_Coord(y) 
 8877      iw = convert_to_FL_Coord(w) 
 8878      ih = convert_to_FL_Coord(h) 
 8879      slabel = convert_to_string(label) 
 8880      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8881                     ih, slabel) 
 8882      retval = _fl_add_bitmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8883      return retval 
 8884   
 8885   
 8886 -def fl_add_scrollbutton(buttontype, x, y, w, h, label): 
 8887      """ 
 8888          fl_add_scrollbutton(buttontype, x, y, w, h, label) -> pObject 
 8889   
 8890          @param buttontype : type of button object to be added 
 8891          @param x : horizontal position of button (upper-left corner) 
 8892          @param x : vertical position of button (upper-left corner) 
 8893          @param w : width of button in pixels 
 8894          @param h : height of button in pixels 
 8895          @param label : text label of button 
 8896      """ 
 8897   
 8898      _fl_add_scrollbutton = cfuncproto( 
 8899              load_so_libforms(), "fl_add_scrollbutton", 
 8900              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8901              FL_Coord, STRING], 
 8902              """FL_OBJECT * fl_add_scrollbutton(int type, FL_Coord x, 
 8903                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8904              """) 
 8905      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8906      ibuttontype = convert_to_int(buttontype) 
 8907      ix = convert_to_FL_Coord(x) 
 8908      iy = convert_to_FL_Coord(y) 
 8909      iw = convert_to_FL_Coord(w) 
 8910      ih = convert_to_FL_Coord(h) 
 8911      slabel = convert_to_string(label) 
 8912      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8913                     ih, slabel) 
 8914      retval = _fl_add_scrollbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8915      return retval 
 8916   
 8917   
 8918 -def fl_add_labelbutton(buttontype, x, y, w, h, label): 
 8919      """ 
 8920          fl_add_labelbutton(buttontype, x, y, w, h, label) -> pObject 
 8921   
 8922          @param buttontype : type of button object to be added 
 8923          @param x : horizontal position of button (upper-left corner) 
 8924          @param x : vertical position of button (upper-left corner) 
 8925          @param w : width of button in pixels 
 8926          @param h : height of button in pixels 
 8927          @param label : text label of button 
 8928      """ 
 8929   
 8930      _fl_add_labelbutton = cfuncproto( 
 8931              load_so_libforms(), "fl_add_labelbutton", 
 8932              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8933              FL_Coord, STRING], 
 8934              """FL_OBJECT * fl_add_labelbutton(int type, FL_Coord x, 
 8935                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8936              """) 
 8937      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8938      ibuttontype = convert_to_int(buttontype) 
 8939      ix = convert_to_FL_Coord(x) 
 8940      iy = convert_to_FL_Coord(y) 
 8941      iw = convert_to_FL_Coord(w) 
 8942      ih = convert_to_FL_Coord(h) 
 8943      slabel = convert_to_string(label) 
 8944      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8945                     ih, slabel) 
 8946      retval = _fl_add_labelbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8947      return retval 
 8948   
 8949   
 8950  fl_set_bitmapbutton_file = fl_set_bitmap_file 
 8951   
 8952   
 8953 -def fl_set_bitmapbutton_data(pObject, w, h, bits): 
 8954      """ fl_set_bitmapbutton_data(pObject, w, h, bits) 
 8955      """ 
 8956   
 8957      _fl_set_bitmapbutton_data = cfuncproto( 
 8958              load_so_libforms(), "fl_set_bitmapbutton_data", 
 8959              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, 
 8960              cty.POINTER(cty.c_ubyte)], 
 8961              """void fl_set_bitmapbutton_data(FL_OBJECT * ob, int w, int h, 
 8962                 unsigned char * bits) 
 8963              """) 
 8964      iw = convert_to_int(w) 
 8965      ih = convert_to_int(h) 
 8966      pbits = cty.cast(bits, cty.POINTER(cty.c_ubyte)) 
 8967      keep_elem_refs(pObject, w, h, bits, iw, ih, pbits) 
 8968      _fl_set_bitmapbutton_data(pObject, iw, ih, pbits) 
 8969   
 8970   
 8971  fl_set_bitmapbutton_datafile = fl_set_bitmapbutton_file 
 8972   
 8973   
 8974 -def fl_add_pixmapbutton(buttontype, x, y, w, h, label): 
 8975      """ 
 8976          fl_add_pixmapbutton(buttontype, x, y, w, h, label) -> pObject 
 8977   
 8978          @param buttontype : type of button object to be added 
 8979          @param x : horizontal position of button (upper-left corner) 
 8980          @param x : vertical position of button (upper-left corner) 
 8981          @param w : width of button in pixels 
 8982          @param h : height of button in pixels 
 8983          @param label : text label of button 
 8984      """ 
 8985   
 8986      _fl_add_pixmapbutton = cfuncproto( 
 8987              load_so_libforms(), "fl_add_pixmapbutton", 
 8988              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8989              FL_Coord, STRING], 
 8990              """FL_OBJECT * fl_add_pixmapbutton(int type, FL_Coord x, 
 8991                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8992              """) 
 8993      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8994      ibuttontype = convert_to_int(buttontype) 
 8995      ix = convert_to_FL_Coord(x) 
 8996      iy = convert_to_FL_Coord(y) 
 8997      iw = convert_to_FL_Coord(w) 
 8998      ih = convert_to_FL_Coord(h) 
 8999      slabel = convert_to_string(label) 
 9000      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 9001                     ih, slabel) 
 9002      retval = _fl_add_pixmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 9003      return retval 
 9004   
 9005   
 9006 -def fl_set_pixmapbutton_focus_outline(pObject, yes): 
 9007      """ fl_set_pixmapbutton_focus_outline(pObject, yes) 
 9008      """ 
 9009   
 9010      _fl_set_pixmapbutton_focus_outline = cfuncproto( 
 9011              load_so_libforms(), "fl_set_pixmapbutton_focus_outline", 
 9012              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 9013              """void fl_set_pixmapbutton_focus_outline(FL_OBJECT * ob, int yes) 
 9014              """) 
 9015      iyes = convert_to_int(yes) 
 9016      keep_elem_refs(pObject, yes, iyes) 
 9017      _fl_set_pixmapbutton_focus_outline(pObject, iyes) 
 9018   
 9019   
 9020  fl_set_pixmapbutton_data = fl_set_pixmap_data 
 9021  fl_set_pixmapbutton_file = fl_set_pixmap_file 
 9022  fl_set_pixmapbutton_pixmap = fl_set_pixmap_pixmap 
 9023  fl_get_pixmapbutton_pixmap = fl_get_pixmap_pixmap 
 9024  fl_set_pixmapbutton_align = fl_set_pixmap_align 
 9025  fl_free_pixmapbutton_pixmap = fl_free_pixmap_pixmap 
 9026  fl_set_pixmapbutton_datafile = fl_set_pixmapbutton_file 
 9027  fl_set_pixmapbutton_show_focus = fl_set_pixmapbutton_focus_outline 
 9028   
 9029   
 9030 -def fl_set_pixmapbutton_focus_data(pObject, bits): 
 9031      """ fl_set_pixmapbutton_focus_data(pObject, bits) 
 9032      """ 
 9033   
 9034      _fl_set_pixmapbutton_focus_data = cfuncproto( 
 9035              load_so_libforms(), "fl_set_pixmapbutton_focus_data", 
 9036              None, [cty.POINTER(FL_OBJECT), cty.POINTER(STRING)], 
 9037              """void fl_set_pixmapbutton_focus_data(FL_OBJECT * ob, 
 9038                 char * * bits) 
 9039              """) 
 9040      keep_elem_refs(pObject, bits) 
 9041      _fl_set_pixmapbutton_focus_data(pObject, bits) 
 9042   
 9043   
 9044 -def fl_set_pixmapbutton_focus_file(pObject, fname): 
 9045      """ fl_set_pixmapbutton_focus_file(pObject, fname) 
 9046      """ 
 9047   
 9048      _fl_set_pixmapbutton_focus_file = cfuncproto( 
 9049              load_so_libforms(), "fl_set_pixmapbutton_focus_file", 
 9050              None, [cty.POINTER(FL_OBJECT), STRING], 
 9051              """void fl_set_pixmapbutton_focus_file(FL_OBJECT * ob, 
 9052                 const char * fname) 
 9053              """) 
 9054      sfname = convert_to_string(fname) 
 9055      keep_elem_refs(pObject, fname, sfname) 
 9056      _fl_set_pixmapbutton_focus_file(pObject, sfname) 
 9057   
 9058   
 9059 -def fl_set_pixmapbutton_focus_pixmap(pObject, idnum, mask): 
 9060      """ fl_set_pixmapbutton_focus_pixmap(pObject, idnum, mask) 
 9061      """ 
 9062   
 9063      _fl_set_pixmapbutton_focus_pixmap = cfuncproto( 
 9064              load_so_libforms(), "fl_set_pixmapbutton_focus_pixmap", 
 9065              None, [cty.POINTER(FL_OBJECT), Pixmap, Pixmap], 
 9066              """void fl_set_pixmapbutton_focus_pixmap(FL_OBJECT * ob, 
 9067                 Pixmap id, Pixmap mask) 
 9068              """) 
 9069      ulidnum = convert_to_ulong(idnum) 
 9070      ulmask = convert_to_ulong(mask) 
 9071      keep_elem_refs(pObject, idnum, mask, ulidnum, ulmask) 
 9072      _fl_set_pixmapbutton_focus_pixmap(pObject, ulidnum, ulmask) 
 9073   
 9074   
 9075 -def fl_get_button(pObject): 
 9076      """ 
 9077          fl_get_button(pObject) -> num. 
 9078   
 9079          Returns the value of the button. 
 9080   
 9081          @param pObject : pointer to button object 
 9082      """ 
 9083   
 9084      _fl_get_button = cfuncproto( 
 9085              load_so_libforms(), "fl_get_button", 
 9086              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 9087              """int fl_get_button(FL_OBJECT * ob) 
 9088              """) 
 9089      keep_elem_refs(pObject) 
 9090      retval = _fl_get_button(pObject) 
 9091      return retval 
 9092   
 9093   
 9094 -def fl_set_button(pObject, pushed): 
 9095      """ 
 9096          fl_set_button(pObject, pushed) 
 9097   
 9098          Sets the button state (not pushed/pushed). 
 9099   
 9100          @param pObject : pointer to button object 
 9101          @param pushed : state of button to be set (0|1) 
 9102      """ 
 9103   
 9104      _fl_set_button = cfuncproto( 
 9105              load_so_libforms(), "fl_set_button", 
 9106              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 9107              """void fl_set_button(FL_OBJECT * ob, int pushed) 
 9108              """) 
 9109      ipushed = convert_to_int(pushed) 
 9110      keep_elem_refs(pObject, pushed, ipushed) 
 9111      _fl_set_button(pObject, ipushed) 
 9112   
 9113   
 9114 -def fl_get_button_numb(pObject): 
 9115      """ 
 9116          fl_get_button_numb(pObject) -> num. 
 9117   
 9118          Returns the number of the last used  mouse button. fl_mouse_button 
 9119          will also return the mouse number. 
 9120   
 9121          @param pObject : pointer to button object 
 9122      """ 
 9123   
 9124      _fl_get_button_numb = cfuncproto( 
 9125              load_so_libforms(), "fl_get_button_numb", 
 9126              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 9127              """int fl_get_button_numb(FL_OBJECT * ob) 
 9128              """) 
 9129      keep_elem_refs(pObject) 
 9130      retval = _fl_get_button_numb(pObject) 
 9131      return retval 
 9132   
 9133   
 9134  fl_set_button_shortcut = fl_set_object_shortcut 
 9135   
 9136   
 9137 -def fl_create_generic_button(objclass, buttontype, x, y, w, h, label): 
 9138      """ 
 9139          fl_create_generic_button(objclass, buttontype, x, y, w, h, label) -> pObject 
 9140   
 9141          Creates a generic button object. 
 9142   
 9143          @param objclass : value of a new button class 
 9144          @param buttontype : type of button object to be created 
 9145          @param x : horizontal position of button (upper-left corner) 
 9146          @param x : vertical position of button (upper-left corner) 
 9147          @param w : width of button in pixels 
 9148          @param h : height of button in pixels 
 9149          @param label : text label of button 
 9150      """ 
 9151   
 9152      _fl_create_generic_button = cfuncproto( 
 9153              load_so_libforms(), "fl_create_generic_button", 
 9154              cty.POINTER(FL_OBJECT), [cty.c_int, cty.c_int, FL_Coord, FL_Coord, 
 9155              FL_Coord, FL_Coord, STRING], 
 9156              """FL_OBJECT * fl_create_generic_button(int objclass, int type, 
 9157                 FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, 
 9158                 const char * label) 
 9159              """) 
 9160      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 9161      iobjclass = convert_to_int(objclass) 
 9162      ibuttontype = convert_to_int(buttontype) 
 9163      ix = convert_to_FL_Coord(x) 
 9164      iy = convert_to_FL_Coord(y) 
 9165      iw = convert_to_FL_Coord(w) 
 9166      ih = convert_to_FL_Coord(h) 
 9167      slabel = convert_to_string(label) 
 9168      keep_elem_refs(objclass, buttontype, x, y, w, h, label, iobjclass, 
 9169                     ibuttontype, ix, iy, iw, ih, slabel) 
 9170      retval = _fl_create_generic_button(iobjclass, ibuttontype, ix, iy, 
 9171                                         iw, ih, slabel) 
 9172      return retval 
 9173   
 9174   
 9175  FL_DrawButton = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT)) 
 9176  FL_CleanupButton = cty.CFUNCTYPE(None, cty.POINTER(FL_BUTTON_SPEC)) 
 9177   
 9178  FL_DRAWBUTTON = FL_DrawButton 
 9179  FL_CLEANUPBUTTON = FL_CleanupButton 
 9180   
 9181 -def fl_add_button_class(bclass, py_DrawButton, py_CleanupButton): 
 9182      """ 
 9183          fl_add_button_class(bclass, py_DrawButton, py_CleanupButton) 
 9184   
 9185          Associates a button class with a drawing function. 
 9186   
 9187          @param bclass : value of a new button class 
 9188          @param py_DrawButton : python function to draw button, fn(pObject) 
 9189          @param py_CleanupButton : python function to cleanup button, 
 9190             fn(pButtonSpec) 
 9191      """ 
 9192   
 9193      _fl_add_button_class = cfuncproto( 
 9194              load_so_libforms(), "fl_add_button_class", 
 9195              None, [cty.c_int, FL_DrawButton, FL_CleanupButton], 
 9196              """void fl_add_button_class(int bclass, FL_DrawButton drawit, 
 9197                 FL_CleanupButton cleanup) 
 9198              """) 
 9199      ibclass = convert_to_int(bclass) 
 9200      c_DrawButton = FL_DrawButton(py_DrawButton) 
 9201      c_CleanupButton = FL_CleanupButton(py_CleanupButton) 
 9202      keep_cfunc_refs(c_DrawButton, py_DrawButton, c_CleanupButton, 
 9203         py_CleanupButton) 
 9204      keep_elem_refs(bclass, ibclass) 
 9205      _fl_add_button_class(ibclass, c_DrawButton, c_CleanupButton) 
 9206   
 9207   
 9208 -def fl_set_button_mouse_buttons(pObject, buttons): 
 9209      """ 
 9210          fl_set_button_mouse_buttons(pObject, buttons) 
 9211   
 9212          Function allows to set up to which mouse buttons the button object 
 9213          will react. 
 9214   
 9215          @param pObject : pointer to button object 
 9216          @param buttons : value of mouse buttons to be set 
 9217      """ 
 9218   
 9219      _fl_set_button_mouse_buttons = cfuncproto( 
 9220              load_so_libforms(), "fl_set_button_mouse_buttons", 
 9221              None, [cty.POINTER(FL_OBJECT), cty.c_uint], 
 9222              """void fl_set_button_mouse_buttons(FL_OBJECT * ob, 
 9223                 unsigned int buttons) 
 9224              """) 
 9225      ibuttons = convert_to_int(buttons) 
 9226      keep_elem_refs(pObject, buttons, ibuttons) 
 9227      _fl_set_button_mouse_buttons(pObject, ibuttons) 
 9228   
 9229   
 9230  #def fl_get_button_mouse_buttons(pObject, buttons)       *API change* 
 9231 -def fl_get_button_mouse_buttons(pObject): 
 9232      """ 
 9233          fl_get_button_mouse_buttons(pObject) -> buttons value 
 9234   
 9235          Returns a value indicating which mouse buttons the button object 
 9236          will react to. 
 9237   
 9238          @param pObject : pointer to button object 
 9239      """ 
 9240   
 9241      _fl_get_button_mouse_buttons = cfuncproto( 
 9242              load_so_libforms(), "fl_get_button_mouse_buttons", 
 9243              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_uint)], 
 9244              """void fl_get_button_mouse_buttons(FL_OBJECT * ob, 
 9245                 unsigned int * buttons) 
 9246              """) 
 9247      buttons, pbuttons = make_uint_and_pointer() 
 9248      keep_elem_refs(pObject, buttons, pbuttons) 
 9249      _fl_get_button_mouse_buttons(pObject, pbuttons) 
 9250      return buttons 
 9251   
 9252   
 9253  ####################### 
 9254  # forms.h (canvas.h) 
 9255  # Header for FL_CANVAS 
 9256  ####################### 
 9257   
 9258  # Interfaces 
 9259   
 9260 -def fl_create_generic_canvas(canvasclass, canvastype, x, y, w, h, label): 
 9261      """ 
 9262          fl_create_generic_canvas(canvasclass, canvastype, x, y, w, h, label) -> pObject 
 9263   
 9264          Creates a generic canvas object. 
 9265   
 9266          @param canvasclass : value of a new canvas class 
 9267          @param canvastype : type of canvas object to be created 
 9268          @param x : horizontal position of canvas (upper-left corner) 
 9269          @param x : vertical position of canvas (upper-left corner) 
 9270          @param w : width of canvas in pixels 
 9271          @param h : height of canvas in pixels 
 9272          @param label : text label of canvas 
 9273      """ 
 9274   
 9275      _fl_create_generic_canvas = cfuncproto( 
 9276              load_so_libforms(), "fl_create_generic_canvas", 
 9277              cty.POINTER(FL_OBJECT), [cty.c_int, cty.c_int, FL_Coord, FL_Coord, 
 9278              FL_Coord, FL_Coord, STRING], 
 9279              """FL_OBJECT * fl_create_generic_canvas(int canvas_class, 
 9280                 int type, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, 
 9281                 const char * label) 
 9282              """) 
 9283      check_admitted_listvalues(canvastype, CANVASTYPE_list) 
 9284      icanvasclass = convert_to_int(canvasclass) 
 9285      icanvastype = convert_to_int(canvastype) 
 9286      ix = convert_to_FL_Coord(x) 
 9287      iy = convert_to_FL_Coord(y) 
 9288      iw = convert_to_FL_Coord(w) 
 9289      ih = convert_to_FL_Coord(h) 
 9290      slabel = convert_to_string(label) 
 9291      keep_elem_refs(canvasclass, canvastype, x, y, w, h, label, icanvasclass, 
 9292                     icanvastype, ix, iy, iw, ih, slabel) 
 9293      retval = _fl_create_generic_canvas(icanvasclass, icanvastype, ix, iy, iw, ih, 
 9294                                    slabel) 
 9295      return retval 
 9296   
 9297   
 9298 -def fl_add_canvas(canvastype, x, y, w, h, label): 
 9299      """ 
 9300          fl_add_canvas(canvastype, x, y, w, h, label) -> pObject 
 9301   
 9302          Adds a canvas object. 
 9303   
 9304          @param canvastype : type of canvas object to be added 
 9305          @param x : horizontal position of canvas (upper-left corner) 
 9306          @param x : vertical position of canvas (upper-left corner) 
 9307          @param w : width of canvas in pixels 
 9308          @param h : height of canvas in pixels 
 9309          @param label : text label of canvas 
 9310      """ 
 9311   
 9312      _fl_add_canvas = cfuncproto( 
 9313              load_so_libforms(), "fl_add_canvas", 
 9314              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 9315              FL_Coord, STRING], 
 9316              """FL_OBJECT * fl_add_canvas(int type, FL_Coord x, FL_Coord y, 
 9317                 FL_Coord w, FL_Coord h, const char * label) 
 9318              """) 
 9319      check_admitted_listvalues(canvastype, CANVASTYPE_list) 
 9320      icanvastype = convert_to_int(canvastype) 
 9321      ix = convert_to_FL_Coord(x) 
 9322      iy = convert_to_FL_Coord(y) 
 9323      iw = convert_to_FL_Coord(w) 
 9324      ih = convert_to_FL_Coord(h) 
 9325      slabel = convert_to_string(label) 
 9326      keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 
 9327                     iw, ih, slabel) 
 9328      retval = _fl_add_canvas(icanvastype, ix, iy, iw, ih, slabel) 
 9329      return retval 
 9330   
 9331   
 9332 -def fl_create_canvas(canvastype, x, y, w, h, label): 
 9333      """ 
 9334          fl_create_canvas(canvastype, x, y, w, h, label) -> pObject 
 9335   
 9336          Creates a canvas object. 
 9337   
 9338          @param canvastype : type of canvas object to be created 
 9339          @param x : horizontal position of canvas (upper-left corner) 
 9340          @param x : vertical position of canvas (upper-left corner) 
 9341          @param w : width of canvas in pixels 
 9342          @param h : height of canvas in pixels 
 9343          @param label : text label of canvas 
 9344      """ 
 9345   
 9346      _fl_create_canvas = cfuncproto( 
 9347              load_so_libforms(), "fl_create_canvas", 
 9348              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 9349              FL_Coord, STRING], 
 9350              """FL_OBJECT * fl_create_canvas(int type, FL_Coord x, FL_Coord y, 
 9351                 FL_Coord w, FL_Coord h, const char * label) 
 9352              """) 
 9353      check_admitted_listvalues(canvastype, CANVASTYPE_list) 
 9354      icanvastype = convert_to_int(canvastype) 
 9355      ix = convert_to_FL_Coord(x) 
 9356      iy = convert_to_FL_Coord(y) 
 9357      iw = convert_to_FL_Coord(w) 
 9358      ih = convert_to_FL_Coord(h) 
 9359      slabel = convert_to_string(label) 
 9360      keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 
 9361                     iw, ih, slabel) 
 9362      retval = _fl_create_canvas(icanvastype, ix, iy, iw, ih, slabel) 
 9363      return retval 
 9364   
 9365   
 9366  # backward compatibility 
 9367  fl_set_canvas_decoration = fl_set_object_boxtype 
 9368   
 9369   
 9370 -def fl_set_canvas_colormap(pObject, colormap): 
 9371      """ fl_set_canvas_colormap(pObject, colormap) 
 9372      """ 
 9373   
 9374      _fl_set_canvas_colormap = cfuncproto( 
 9375              load_so_libforms(), "fl_set_canvas_colormap", 
 9376              None, [cty.POINTER(FL_OBJECT), Colormap], 
 9377              """void fl_set_canvas_colormap(FL_OBJECT * ob, Colormap colormap) 
 9378              """) 
 9379      ulcolormap = convert_to_ulong(colormap) 
 9380      keep_elem_refs(pObject, colormap, ulcolormap) 
 9381      _fl_set_canvas_colormap(pObject, ulcolormap) 
 9382   
 9383   
 9384 -def fl_set_canvas_visual(pObject, vi): 
 9385      """ fl_set_canvas_visual(pObject, vi) 
 9386      """ 
 9387   
 9388      _fl_set_canvas_visual = cfuncproto( 
 9389              load_so_libforms(), "fl_set_canvas_visual", 
 9390              None, [cty.POINTER(FL_OBJECT), cty.POINTER(Visual)], 
 9391              """void fl_set_canvas_visual(FL_OBJECT * obj, Visual * vi) 
 9392              """) 
 9393      keep_elem_refs(pObject, vi) 
 9394      _fl_set_canvas_visual(pObject, vi) 
 9395   
 9396   
 9397 -def fl_set_canvas_depth(pObject, depth): 
 9398      """ fl_set_canvas_depth(pObject, depth) 
 9399      """ 
 9400   
 9401      _fl_set_canvas_depth = cfuncproto( 
 9402              load_so_libforms(), "fl_set_canvas_depth", 
 9403              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 9404              """void fl_set_canvas_depth(FL_OBJECT * obj, int depth) 
 9405              """) 
 9406      idepth = convert_to_int(depth) 
 9407      keep_elem_refs(pObject, depth, idepth) 
 9408      _fl_set_canvas_depth(pObject, idepth) 
 9409   
 9410   
 9411 -def fl_set_canvas_attributes(pObject, mask, pXSetWindowAttributes): 
 9412      """ fl_set_canvas_attributes(pObject, mask, pXSetWindowAttributes) 
 9413      """ 
 9414   
 9415      _fl_set_canvas_attributes = cfuncproto( 
 9416              load_so_libforms(), "fl_set_canvas_attributes", 
 9417              None, [cty.POINTER(FL_OBJECT), cty.c_uint, 
 9418              cty.POINTER(XSetWindowAttributes)], 
 9419              """void fl_set_canvas_attributes(FL_OBJECT * ob, 
 9420                 unsigned int mask, XSetWindowAttributes * xswa) 
 9421              """) 
 9422      uimask = convert_to_uint(mask) 
 9423      keep_elem_refs(pObject, mask, pXSetWindowAttributes, uimask) 
 9424      _fl_set_canvas_attributes(pObject, uimask, pXSetWindowAttributes) 
 9425   
 9426   
 9427  FL_HANDLE_CANVAS = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), Window, 
 9428              cty.c_int, cty.c_int, cty.POINTER(XEvent), cty.c_void_p) 
 9429   
 9430 -def fl_add_canvas_handler(pObject, ev, py_HandleCanvas, udata): 
 9431      """ fl_add_canvas_handler(pObject, ev, py_HandleCanvas, udata) -> canvas handler 
 9432      """ 
 9433   
 9434      _fl_add_canvas_handler = cfuncproto( 
 9435              load_so_libforms(), "fl_add_canvas_handler", 
 9436              FL_HANDLE_CANVAS, [cty.POINTER(FL_OBJECT), cty.c_int, 
 9437              FL_HANDLE_CANVAS, cty.c_void_p], 
 9438              """FL_HANDLE_CANVAS fl_add_canvas_handler(FL_OBJECT * ob, int ev, 
 9439                 FL_HANDLE_CANVAS h, void * udata) 
 9440              """) 
 9441      iev = convert_to_int(ev) 
 9442      c_HandleCanvas = FL_HANDLE_CANVAS(py_HandleCanvas) 
 9443      pudata = cty.cast(udata, cty.c_void_p) 
 9444      keep_cfunc_refs(c_HandleCanvas, py_HandleCanvas) 
 9445      keep_elem_refs(pObject, ev, udata, iev, pudata) 
 9446      retval = _fl_add_canvas_handler(pObject, iev, c_HandleCanvas, pudata) 
 9447      return retval 
 9448   
 9449   
 9450 -def fl_get_canvas_id(pObject): 
 9451      """ 
 9452          fl_get_canvas_id(pObject) -> window 
 9453   
 9454          Returns the window ID of the canvas window. 
 9455   
 9456          @param pObject : pointer to canvas object 
 9457      """ 
 9458   
 9459      _fl_get_canvas_id = cfuncproto( 
 9460              load_so_libforms(), "fl_get_canvas_id", 
 9461              Window, [cty.POINTER(FL_OBJECT)], 
 9462              """Window fl_get_canvas_id(FL_OBJECT * ob) 
 9463              """) 
 9464      keep_elem_refs(pObject) 
 9465      retval = _fl_get_canvas_id(pObject) 
 9466      return retval 
 9467   
 9468   
 9469 -def fl_get_canvas_colormap(pObject): 
 9470      """ fl_get_canvas_colormap(pObject) -> colormap 
 9471      """ 
 9472   
 9473      _fl_get_canvas_colormap = cfuncproto( 
 9474              load_so_libforms(), "fl_get_canvas_colormap", 
 9475              Colormap, [cty.POINTER(FL_OBJECT)], 
 9476              """Colormap fl_get_canvas_colormap(FL_OBJECT * ob) 
 9477              """) 
 9478      keep_elem_refs(pObject) 
 9479      retval = _fl_get_canvas_colormap(pObject) 
 9480      return retval 
 9481   
 9482   
 9483 -def fl_get_canvas_depth(pObject): 
 9484      """ fl_get_canvas_depth(pObject) -> depth num. 
 9485      """ 
 9486   
 9487      _fl_get_canvas_depth = cfuncproto( 
 9488              load_so_libforms(), "fl_get_canvas_depth", 
 9489              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 9490              """int fl_get_canvas_depth(FL_OBJECT * obj) 
 9491              """) 
 9492      keep_elem_refs(pObject) 
 9493      retval = _fl_get_canvas_depth(pObject) 
 9494      return retval 
 9495   
 9496   
 9497 -def fl_remove_canvas_handler(pObject, ev, py_HandleCanvas): 
 9498      """ 
 9499          fl_remove_canvas_handler(pObject, ev, py_HandleCanvas) 
 9500   
 9501          Remove a particular handler for event ev. If ev is invalid, removes 
 9502          all handlers and their corresponding event mask. 
 9503   
 9504          @param pObject : pointer to canvas object 
 9505          @param ev : event number 
 9506          @param py_HandleCanvas : python function for canvas handler 
 9507      """ 
 9508   
 9509      _fl_remove_canvas_handler = cfuncproto( 
 9510              load_so_libforms(), "fl_remove_canvas_handler", 
 9511              None, [cty.POINTER(FL_OBJECT), cty.c_int, FL_HANDLE_CANVAS], 
 9512              """void fl_remove_canvas_handler(FL_OBJECT * ob, int ev, 
 9513                 FL_HANDLE_CANVAS h) 
 9514              """) 
 9515      iev = convert_to_int(ev) 
 9516      c_HandleCanvas = FL_HANDLE_CANVAS(py_HandleCanvas) 
 9517      keep_cfunc_refs(c_HandleCanvas, py_HandleCanvas) 
 9518      keep_elem_refs(pObject, ev, iev) 
 9519      _fl_remove_canvas_handler(pObject, iev, c_HandleCanvas) 
 9520   
 9521   
 9522 -def fl_hide_canvas(pObject): 
 9523      """ 
 9524          fl_hide_canvas(pObject) 
 9525   
 9526          Hides a canvas object. 
 9527   
 9528          @param pObject : pointer to canvas object 
 9529      """ 
 9530   
 9531      _fl_hide_canvas = cfuncproto( 
 9532              load_so_libforms(), "fl_hide_canvas", 
 9533              None, [cty.POINTER(FL_OBJECT)], 
 9534              """void fl_hide_canvas(FL_OBJECT * ob) 
 9535              """) 
 9536      keep_elem_refs(pObject) 
 9537      _fl_hide_canvas(pObject) 
 9538   
 9539   
 9540 -def fl_share_canvas_colormap(pObject, colormap): 
 9541      """ fl_share_canvas_colormap(pObject, colormap) 
 9542      """ 
 9543   
 9544      _fl_share_canvas_colormap = cfuncproto( 
 9545              load_so_libforms(), "fl_share_canvas_colormap", 
 9546              None, [cty.POINTER(FL_OBJECT), Colormap], 
 9547              """void fl_share_canvas_colormap(FL_OBJECT * ob, Colormap colormap) 
 9548              """) 
 9549      ulcolormap = convert_to_ulong(colormap) 
 9550      keep_elem_refs(pObject, colormap, ulcolormap) 
 9551      _fl_share_canvas_colormap(pObject, ulcolormap) 
 9552   
 9553   
 9554 -def fl_clear_canvas(pObject): 
 9555      """ 
 9556          fl_clear_canvas(pObject) 
 9557   
 9558          Clears the canvas to the background color. If no background is 
 9559          defined use black. 
 9560   
 9561          @param pObject : pointer to canvas object 
 9562      """ 
 9563   
 9564      _fl_clear_canvas = cfuncproto( 
 9565              load_so_libforms(), "fl_clear_canvas", 
 9566              None, [cty.POINTER(FL_OBJECT)], 
 9567              """void fl_clear_canvas(FL_OBJECT * ob) 
 9568              """) 
 9569      keep_elem_refs(pObject) 
 9570      _fl_clear_canvas(pObject) 
 9571   
 9572   
 9573  FL_MODIFY_CANVAS_PROP = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT)) 
 9574   
 9575 -def fl_modify_canvas_prop(pObject, py_initModifyCanvasProp, \ 
 9576       py_activateModifyCanvasProp, py_cleanupModifyCanvasProp): 
 9577      """ 
 9578          fl_modify_canvas_prop(pObject, py_initModifyCanvasProp, \ 
 9579          py_activateModifyCanvasProp, py_cleanupModifyCanvasProp) 
 9580   
 9581      """ 
 9582   
 9583      _fl_modify_canvas_prop = cfuncproto( 
 9584              load_so_libforms(), "fl_modify_canvas_prop", 
 9585              None, [cty.POINTER(FL_OBJECT), FL_MODIFY_CANVAS_PROP, 
 9586              FL_MODIFY_CANVAS_PROP, FL_MODIFY_CANVAS_PROP], 
 9587              """void fl_modify_canvas_prop(FL_OBJECT * obj, 
 9588                 FL_MODIFY_CANVAS_PROP init, FL_MODIFY_CANVAS_PROP activate, 
 9589                 FL_MODIFY_CANVAS_PROP cleanup) 
 9590              """) 
 9591      c_initModifyCanvasProp = FL_MODIFY_CANVAS_PROP(py_initModifyCanvasProp) 
 9592      c_activateModifyCanvasProp = FL_MODIFY_CANVAS_PROP( \ 
 9593                  py_activateModifyCanvasProp) 
 9594      c_cleanupModifyCanvasProp = FL_MODIFY_CANVAS_PROP( \ 
 9595                  py_cleanupModifyCanvasProp) 
 9596      keep_cfunc_refs(c_initModifyCanvasProp, py_initModifyCanvasProp, \ 
 9597                  c_activateModifyCanvasProp, py_activateModifyCanvasProp, \ 
 9598                  c_cleanupModifyCanvasProp, py_cleanupModifyCanvasProp) 
 9599      keep_elem_refs(pObject) 
 9600      _fl_modify_canvas_prop(pObject, c_initModifyCanvasProp, 
 9601                      c_activateModifyCanvasProp, c_cleanupModifyCanvasProp) 
 9602   
 9603   
 9604 -def fl_canvas_yield_to_shortcut(pObject, yes): 
 9605      """ fl_canvas_yield_to_shortcut(pObject, yes) 
 9606      """ 
 9607   
 9608      _fl_canvas_yield_to_shortcut = cfuncproto( 
 9609              load_so_libforms(), "fl_canvas_yield_to_shortcut", 
 9610              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 9611              """void fl_canvas_yield_to_shortcut(FL_OBJECT * ob, int yes) 
 9612              """) 
 9613      iyes = convert_to_int(yes) 
 9614      keep_elem_refs(pObject, yes, iyes) 
 9615      _fl_canvas_yield_to_shortcut(pObject, iyes) 
 9616   
 9617   
 9618   
 9619  ############# 
 9620  # glcanvas.h 
 9621  ############# 
 9622   
 9623  # This is an attempt to maintain some sort of backwards compatibility 
 9624  # with old code whilst also getting rid of the old, system-specific 
 9625  # hack. 
 9626   
 9627  # OpenGL canvases 
 9628   
 9629 -def fl_create_glcanvas(canvastype, x, y, w, h, label): 
 9630      """ fl_create_glcanvas(canvastype, x, y, w, h, label) -> pObject 
 9631      """ 
 9632   
 9633      _fl_create_glcanvas = cfuncproto( 
 9634              load_so_libformsgl(), "fl_create_glcanvas", 
 9635              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 9636              FL_Coord, STRING], 
 9637              """FL_OBJECT * fl_create_glcanvas(int type, FL_Coord x, FL_Coord y, 
 9638                 FL_Coord w, FL_Coord h, const char * label) 
 9639              """) 
 9640      check_admitted_listvalues(canvastype, CANVASTYPE_list) 
 9641      icanvastype = convert_to_int(canvastype) 
 9642      ix = convert_to_FL_Coord(x) 
 9643      iy = convert_to_FL_Coord(y) 
 9644      iw = convert_to_FL_Coord(w) 
 9645      ih = convert_to_FL_Coord(h) 
 9646      slabel = convert_to_string(label) 
 9647      keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 
 9648                     iw, ih, slabel) 
 9649      retval = _fl_create_glcanvas(icanvastype, ix, iy, iw, ih, slabel) 
 9650      return retval 
 9651   
 9652   
 9653 -def fl_add_glcanvas(canvastype, x, y, w, h, label): 
 9654      """ fl_add_glcanvas(canvastype, x, y, w, h, label) -> pObject 
 9655      """ 
 9656   
 9657      _fl_add_glcanvas = cfuncproto( 
 9658              load_so_libformsgl(), "fl_add_glcanvas", 
 9659              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 9660              FL_Coord, STRING], 
 9661              """FL_OBJECT * fl_add_glcanvas(int type, FL_Coord x, FL_Coord y, 
 9662                 FL_Coord w, FL_Coord h, const char * label) 
 9663              """) 
 9664      check_admitted_listvalues(canvastype, CANVASTYPE_list) 
 9665      icanvastype = convert_to_int(canvastype) 
 9666      ix = convert_to_FL_Coord(x) 
 9667      iy = convert_to_FL_Coord(y) 
 9668      iw = convert_to_FL_Coord(w) 
 9669      ih = convert_to_FL_Coord(h) 
 9670      slabel = convert_to_string(label) 
 9671      keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 
 9672                     iw, ih, slabel) 
 9673      retval = _fl_add_glcanvas(icanvastype, ix, iy, iw, ih, slabel) 
 9674      return retval 
 9675   
 9676   
 9677 -def fl_set_glcanvas_defaults(config): 
 9678      """ fl_set_glcanvas_defaults(config): 
 9679      """ 
 9680   
 9681      _fl_set_glcanvas_defaults = cfuncproto( 
 9682              load_so_libformsgl(), "fl_set_glcanvas_defaults", 
 9683              None, [cty.POINTER(cty.c_int)], 
 9684              """void fl_set_glcanvas_defaults(const int * config): 
 9685              """) 
 9686      #iconfig = convert_to_int(config) 
 9687      keep_elem_refs(config)  #, iconfig) 
 9688      _fl_set_glcanvas_defaults(config) 
 9689   
 9690   
 9691 -def fl_get_glcanvas_defaults(config): 
 9692      """ fl_get_glcanvas_defaults(config): 
 9693      """ 
 9694   
 9695      _fl_get_glcanvas_defaults = cfuncproto( 
 9696              load_so_libformsgl(), "fl_get_glcanvas_defaults", 
 9697              None, [cty.c_int], 
 9698              """void fl_get_glcanvas_defaults(int config[ ]): 
 9699              """) 
 9700      iconfig = convert_to_int(config) 
 9701      keep_elem_refs(config, iconfig) 
 9702      _fl_get_glcanvas_defaults(iconfig) 
 9703   
 9704   
 9705 -def fl_set_glcanvas_attributes(pObject, config): 
 9706      """ fl_set_glcanvas_attributes(pObject, config) 
 9707      """ 
 9708   
 9709      _fl_set_glcanvas_attributes = cfuncproto( 
 9710              load_so_libformsgl(), "fl_set_glcanvas_attributes", 
 9711              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int)], 
 9712              """void fl_set_glcanvas_attributes(FL_OBJECT * ob, 
 9713                 const int * config) 
 9714              """) 
 9715      keep_elem_refs(pObject, config) 
 9716      _fl_set_glcanvas_attributes(pObject, config) 
 9717   
 9718   
 9719 -def fl_get_glcanvas_attributes(pObject, attributes): 
 9720      """ fl_get_glcanvas_attributes(pObject, attributes) 
 9721      """ 
 9722   
 9723      _fl_get_glcanvas_attributes = cfuncproto( 
 9724              load_so_libformsgl(), "fl_get_glcanvas_attributes", 
 9725              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int)], 
 9726              """void fl_get_glcanvas_attributes(FL_OBJECT * ob, 
 9727                 int * attributes) 
 9728              """) 
 9729      keep_elem_refs(pObject, attributes) 
 9730      _fl_get_glcanvas_attributes(pObject, attributes) 
 9731   
 9732   
 9733 -def fl_set_glcanvas_direct(pObject, direct): 
 9734      """ fl_set_glcanvas_direct(pObject, direct) 
 9735      """ 
 9736   
 9737      _fl_set_glcanvas_direct = cfuncproto( 
 9738              load_so_libformsgl(), "fl_set_glcanvas_direct", 
 9739              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 9740              """void fl_set_glcanvas_direct(FL_OBJECT * ob, int direct) 
 9741              """) 
 9742      idirect = convert_to_int(direct) 
 9743      keep_elem_refs(pObject, direct, idirect) 
 9744      _fl_set_glcanvas_direct(pObject, idirect) 
 9745   
 9746   
 9747 -def fl_activate_glcanvas(pObject): 
 9748      """ fl_activate_glcanvas(pObject) 
 9749      """ 
 9750   
 9751      _fl_activate_glcanvas = cfuncproto( 
 9752              load_so_libformsgl(), "fl_activate_glcanvas", 
 9753              None, [cty.POINTER(FL_OBJECT)], 
 9754              """void fl_activate_glcanvas(FL_OBJECT * ob) 
 9755              """) 
 9756      keep_elem_refs(pObject) 
 9757      _fl_activate_glcanvas(pObject) 
 9758   
 9759   
 9760 -def fl_get_glcanvas_xvisualinfo(pObject): 
 9761      """ fl_get_glcanvas_xvisualinfo(pObject) -> xvisualinfo class 
 9762      """ 
 9763   
 9764      _fl_get_glcanvas_xvisualinfo = cfuncproto( 
 9765              load_so_libformsgl(), "fl_get_glcanvas_xvisualinfo", 
 9766              cty.POINTER(XVisualInfo), [cty.POINTER(FL_OBJECT)], 
 9767              """)XVisualInfo * fl_get_glcanvas_xvisualinfo(FL_OBJECT * ob) 
 9768              """) 
 9769      keep_elem_refs(pObject) 
 9770      retval = _fl_get_glcanvas_xvisualinfo(pObject) 
 9771      return retval 
 9772   
 9773   
 9774 -def fl_get_glcanvas_context(pObject): 
 9775      """ fl_get_glcanvas_context(pObject) -> glxcontext class 
 9776      """ 
 9777   
 9778      _fl_get_glcanvas_context = cfuncproto( 
 9779              load_so_libformsgl(), "fl_get_glcanvas_context", 
 9780              GLXContext, [cty.POINTER(FL_OBJECT)], 
 9781              """)GLXContext fl_get_glcanvas_context(FL_OBJECT * ob) 
 9782              """) 
 9783      keep_elem_refs(pObject) 
 9784      retval = _fl_get_glcanvas_context(pObject) 
 9785      return retval 
 9786   
 9787   
 9788 -def fl_glwincreate(config, pGLXContext, w, h): 
 9789      """ fl_glwincreate(config, pGLXContext, w, h) -> window 
 9790      """ 
 9791   
 9792      _fl_glwincreate = cfuncproto( 
 9793              load_so_libformsgl(), "fl_glwincreate", 
 9794              Window, [cty.POINTER(cty.c_int), cty.POINTER(GLXContext), 
 9795              cty.c_int, cty.c_int], 
 9796              """Window fl_glwincreate(int * config, GLXContext * context, 
 9797                 int w, int h) 
 9798              """) 
 9799      iw = convert_to_int(w) 
 9800      ih = convert_to_int(h) 
 9801      keep_elem_refs(config, pGLXContext, w, h, iw, ih) 
 9802      retval = _fl_glwincreate(config, pGLXContext, iw, ih) 
 9803      return retval 
 9804   
 9805   
 9806 -def fl_glwinopen(config, pGLXContext, w, h): 
 9807      """ fl_glwinopen(config, pGLXContext, w, h) -> window 
 9808      """ 
 9809   
 9810      _fl_glwinopen = cfuncproto( 
 9811              load_so_libformsgl(), "fl_glwinopen", 
 9812              Window, [cty.POINTER(cty.c_int), cty.POINTER(GLXContext), 
 9813              cty.c_int, cty.c_int], 
 9814              """Window fl_glwinopen(int * config, GLXContext * context, 
 9815                 int w, int h 
 9816              """) 
 9817      iw = convert_to_int(w) 
 9818      ih = convert_to_int(h) 
 9819      keep_elem_refs(config, pGLXContext, w, h, iw, ih) 
 9820      retval = _fl_glwinopen(config, pGLXContext, iw, ih) 
 9821      return retval 
 9822   
 9823   
 9824   
 9825  ############################# 
 9826  # forms.h (chart.h) 
 9827  # Object Class: Chart 
 9828  ############################# 
 9829   
 9830  # Routines 
 9831   
 9832 -def fl_create_chart(charttype, x, y, w, h, label): 
 9833      """ 
 9834          fl_create_chart(charttype, x, y, w, h, label) -> pObject 
 9835   
 9836          Creates a chart object. 
 9837   
 9838          @param charttype : type of chart object to be created 
 9839          @param x : horizontal position of chart (upper-left corner) 
 9840          @param x : vertical position of chart (upper-left corner) 
 9841          @param w : width of chart in pixels 
 9842          @param h : height of chart in pixels 
 9843          @param label : text label of chart 
 9844      """ 
 9845   
 9846      _fl_create_chart = cfuncproto( 
 9847              load_so_libforms(), "fl_create_chart", 
 9848              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 9849              FL_Coord, STRING], 
 9850              """FL_OBJECT * fl_create_chart(int type, FL_Coord x, FL_Coord y, 
 9851                 FL_Coord w, FL_Coord h, const char * label) 
 9852              """) 
 9853      check_admitted_listvalues(charttype, CHARTTYPE_list) 
 9854      icharttype = convert_to_int(charttype) 
 9855      ix = convert_to_FL_Coord(x) 
 9856      iy = convert_to_FL_Coord(y) 
 9857      iw = convert_to_FL_Coord(w) 
 9858      ih = convert_to_FL_Coord(h) 
 9859      slabel = convert_to_string(label) 
 9860      keep_elem_refs(charttype, x, y, w, h, label, icharttype, ix, iy, 
 9861                     iw, ih, slabel) 
 9862      retval = _fl_create_chart(icharttype, ix, iy, iw, ih, slabel) 
 9863      return retval 
 9864   
 9865   
 9866 -def fl_add_chart(charttype, x, y, w, h, label): 
 9867      """ 
 9868          fl_add_chart(charttype, x, y, w, h, label) -> pObject 
 9869   
 9870          Adds a chart object. 
 9871   
 9872          @param charttype : type of chart object to be created 
 9873          @param x : horizontal position of chart (upper-left corner) 
 9874          @param x : vertical position of chart (upper-left corner) 
 9875          @param w : width of chart in pixels 
 9876          @param h : height of chart in pixels 
 9877          @param label : text label of chart 
 9878      """ 
 9879   
 9880      _fl_add_chart = cfuncproto( 
 9881              load_so_libforms(), "fl_add_chart", 
 9882              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 9883              FL_Coord, STRING], 
 9884              """FL_OBJECT * fl_add_chart(int type, FL_Coord x, FL_Coord y, 
 9885                 FL_Coord w, FL_Coord h, const char * label) 
 9886              """) 
 9887      check_admitted_listvalues(charttype, CHARTTYPE_list) 
 9888      icharttype = convert_to_int(charttype) 
 9889      ix = convert_to_FL_Coord(x) 
 9890      iy = convert_to_FL_Coord(y) 
 9891      iw = convert_to_FL_Coord(w) 
 9892      ih = convert_to_FL_Coord(h) 
 9893      slabel = convert_to_string(label) 
 9894      keep_elem_refs(charttype, x, y, w, h, label, icharttype, ix, iy, 
 9895                     iw, ih, slabel) 
 9896      retval = _fl_add_chart(icharttype, ix, iy, iw, ih, slabel) 
 9897      return retval 
 9898   
 9899   
 9900 -def fl_clear_chart(pObject): 
 9901      """ fl_clear_chart(pObject) 
 9902   
 9903          Clears the contents of a chart. 
 9904   
 9905          @param pObject : pointer to chart object 
 9906      """ 
 9907   
 9908      _fl_clear_chart = cfuncproto( 
 9909              load_so_libforms(), "fl_clear_chart", 
 9910              None, [cty.POINTER(FL_OBJECT)], 
 9911              """void fl_clear_chart(FL_OBJECT * ob) 
 9912              """) 
 9913      keep_elem_refs(pObject) 
 9914      _fl_clear_chart(pObject) 
 9915   
 9916   
 9917 -def fl_add_chart_value(pObject, val, label, col): 
 9918      """ 
 9919          fl_add_chart_value(pObject, val, label, col) 
 9920   
 9921          Adds an item to the chart. 
 9922   
 9923          @param pObject : pointer to chart object 
 9924          @param val : value of chart item 
 9925          @param label : text label of chart object 
 9926          @param col : ? 
 9927      """ 
 9928   
 9929      _fl_add_chart_value = cfuncproto( 
 9930              load_so_libforms(), "fl_add_chart_value", 
 9931              None, [cty.POINTER(FL_OBJECT), cty.c_double, STRING, cty.c_int], 
 9932              """void fl_add_chart_value(FL_OBJECT * ob, double val, 
 9933                 const char * str, int col) 
 9934              """) 
 9935      fval = convert_to_double(val) 
 9936      slabel = convert_to_string(label) 
 9937      icol = convert_to_int(col) 
 9938      keep_elem_refs(pObject, val, label, col, fval, slabel, icol) 
 9939      _fl_add_chart_value(pObject, fval, slabel, icol) 
 9940   
 9941   
 9942 -def fl_insert_chart_value(pObject, indx, val, label, col): 
 9943      """ 
 9944          fl_insert_chart_value(pObject, indx, val, label, col) 
 9945   
 9946          Inserts an item before indx to the chart. 
 9947   
 9948          @param pObject : pointer to chart object 
 9949          @param indx : index position of previous item 
 9950          @param val : value of chart item 
 9951          @param label : text label of chart 
 9952          @param col : ? 
 9953      """ 
 9954   
 9955      _fl_insert_chart_value = cfuncproto( 
 9956              load_so_libforms(), "fl_insert_chart_value", 
 9957              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double, STRING, 
 9958              cty.c_int], 
 9959              """void fl_insert_chart_value(FL_OBJECT * ob, int indx, 
 9960                 double val, const char * str, int col) 
 9961              """) 
 9962      iindx = convert_to_int(indx) 
 9963      fval = convert_to_double(val) 
 9964      slabel = convert_to_string(label) 
 9965      icol = convert_to_int(col) 
 9966      keep_elem_refs(pObject, indx, val, label, col, iindx, fval, 
 9967                     slabel, icol) 
 9968      _fl_insert_chart_value(pObject, iindx, fval, slabel, icol) 
 9969   
 9970   
 9971 -def fl_replace_chart_value(pObject, indx, val, label, col): 
 9972      """ 
 9973          fl_replace_chart_value(pObject, indx, val, label, col) 
 9974   
 9975          Replaces value in the chart. 
 9976   
 9977          @param pObject : pointer to chart object 
 9978          @param indx : index position of item to be replaced 
 9979          @param val : value of chart item 
 9980          @param label : text label of chart 
 9981          @param col : ? 
 9982      """ 
 9983   
 9984      _fl_replace_chart_value = cfuncproto( 
 9985              load_so_libforms(), "fl_replace_chart_value", 
 9986              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double, STRING, 
 9987              cty.c_int], 
 9988              """void fl_replace_chart_value(FL_OBJECT * ob, int indx, 
 9989                 double val, const char * str, int col) 
 9990              """) 
 9991      iindx = convert_to_int(indx) 
 9992      fval = convert_to_double(val) 
 9993      slabel = convert_to_string(label) 
 9994      icol = convert_to_int(col) 
 9995      keep_elem_refs(pObject, indx, val, label, col, iindx, fval, 
 9996                     slabel, icol) 
 9997      _fl_replace_chart_value(pObject, iindx, fval, slabel, icol) 
 9998   
 9999   
10000 -def fl_set_chart_bounds(pObject, minbound, maxbound): 
10001      """ 
10002          fl_set_chart_bounds(pObject, minbound, maxbound) 
10003   
10004          Sets the boundaries/limits for values of a chart object. 
10005   
10006          @param pObject : pointer to chart object 
10007          @param minbound : minimum bounds to be set 
10008          @param maxbound : maximum bounds to be set 
10009      """ 
10010   
10011      _fl_set_chart_bounds = cfuncproto( 
10012              load_so_libforms(), "fl_set_chart_bounds", 
10013              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
10014              """void fl_set_chart_bounds(FL_OBJECT * ob, double min, 
10015                 double max) 
10016              """) 
10017      fminbound = convert_to_double(minbound) 
10018      fmaxbound = convert_to_double(maxbound) 
10019      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
10020      _fl_set_chart_bounds(pObject, fminbound, fmaxbound) 
10021   
10022   
10023  #def fl_get_chart_bounds(pObject, minbound, maxbound)       *API change* 
10024 -def fl_get_chart_bounds(pObject): 
10025      """ 
10026          fl_get_chart_bounds(pObject) -> minbound, maxbound 
10027   
10028          Returns the boundaries/limits set for values of a chart object. 
10029   
10030          @param pObject : pointer to chart object 
10031      """ 
10032   
10033      _fl_get_chart_bounds = cfuncproto( 
10034              load_so_libforms(), "fl_get_chart_bounds", 
10035              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
10036              cty.POINTER(cty.c_double)], 
10037              """void fl_get_chart_bounds(FL_OBJECT * ob, double * min, 
10038                 double * max) 
10039              """) 
10040      minbound, pminbound = make_double_and_pointer() 
10041      maxbound, pmaxbound = make_double_and_pointer() 
10042      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
10043      _fl_get_chart_bounds(pObject, pminbound, pmaxbound) 
10044      return minbound, maxbound 
10045   
10046   
10047 -def fl_set_chart_maxnumb(pObject, maxnum): 
10048      """ 
10049          fl_set_chart_maxnumb(pObject, maxnum) 
10050   
10051          Sets the maximum number of values displayed in the chart. 
10052   
10053          @param pObject : pointer to chart object 
10054          @param maxnum : maximum number of values to display 
10055      """ 
10056   
10057      _fl_set_chart_maxnumb = cfuncproto( 
10058              load_so_libforms(), "fl_set_chart_maxnumb", 
10059              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10060              """void fl_set_chart_maxnumb(FL_OBJECT * ob, int maxnumb) 
10061              """) 
10062      imaxnumb = convert_to_int(maxnum) 
10063      keep_elem_refs(pObject, maxnum, imaxnum) 
10064      _fl_set_chart_maxnumb(pObject, imaxnum) 
10065   
10066   
10067 -def fl_set_chart_autosize(pObject, autosize): 
10068      """ 
10069          fl_set_chart_autosize(pObject, autosize) 
10070   
10071          Sets whether the chart should autosize along the x-axis. 
10072   
10073          @param pObject : pointer to chart object 
10074          @param autosize : autosize flag is enabled/disabled (1|0) 
10075      """ 
10076   
10077      _fl_set_chart_autosize = cfuncproto( 
10078              load_so_libforms(), "fl_set_chart_autosize", 
10079              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10080              """void fl_set_chart_autosize(FL_OBJECT * ob, int autosize) 
10081              """) 
10082      iautosize = convert_to_int(autosize) 
10083      keep_elem_refs(pObject, autosize, iautosize) 
10084      _fl_set_chart_autosize(pObject, iautosize) 
10085   
10086   
10087 -def fl_set_chart_lstyle(pObject, lstyle): 
10088      """ fl_set_chart_lstyle(pObject, lstyle) 
10089      """ 
10090   
10091      _fl_set_chart_lstyle = cfuncproto( 
10092              load_so_libforms(), "fl_set_chart_lstyle", 
10093              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10094              """void fl_set_chart_lstyle(FL_OBJECT * ob, int lstyle) 
10095              """) 
10096      ilstyle = convert_to_int(lstyle) 
10097      keep_elem_refs(pObject, lstyle, ilstyle) 
10098      _fl_set_chart_lstyle(pObject, ilstyle) 
10099   
10100   
10101 -def fl_set_chart_lsize(pObject, lsize): 
10102      """ fl_set_chart_lsize(pObject, lsize) 
10103      """ 
10104   
10105      _fl_set_chart_lsize = cfuncproto( 
10106              load_so_libforms(), "fl_set_chart_lsize", 
10107              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10108              """void fl_set_chart_lsize(FL_OBJECT * ob, int lsize) 
10109              """) 
10110      ilsize = convert_to_int(lsize) 
10111      keep_elem_refs(pObject, lsize, ilsize) 
10112      _fl_set_chart_lsize(pObject, ilsize) 
10113   
10114   
10115 -def fl_set_chart_lcolor(pObject, colr): 
10116      """ fl_set_chart_lcolor(pObject, colr) 
10117      """ 
10118   
10119      _fl_set_chart_lcolor = cfuncproto( 
10120              load_so_libforms(), "fl_set_chart_lcolor", 
10121              None, [cty.POINTER(FL_OBJECT), FL_COLOR], 
10122              """void fl_set_chart_lcolor(FL_OBJECT * ob, FL_COLOR lcol) 
10123              """) 
10124      ulcolr = convert_to_FL_COLOR(colr) 
10125      keep_elem_refs(pObject, colr, ulcolr) 
10126      _fl_set_chart_lcolor(pObject, ulcolr) 
10127   
10128   
10129 -def fl_set_chart_baseline(pObject, yesno): 
10130      """ fl_set_chart_baseline(pObject, yesno) 
10131      """ 
10132   
10133      _fl_set_chart_baseline = cfuncproto( 
10134              load_so_libforms(), "fl_set_chart_baseline", 
10135              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10136              """void fl_set_chart_baseline(FL_OBJECT * ob, int iYesNo) 
10137              """) 
10138      iyesno = convert_to_int(yesno) 
10139      keep_elem_refs(pObject, yesno, iyesno) 
10140      _fl_set_chart_baseline(pObject, iyesno) 
10141   
10142   
10143  fl_set_chart_lcol = fl_set_chart_lcolor 
10144   
10145   
10146   
10147  ##################### 
10148  # forms.h (choice.h) 
10149  ##################### 
10150   
10151  # Routines 
10152   
10153 -def fl_create_choice(choicetype, x, y, w, h, label): 
10154      """ 
10155          fl_create_choice(choicetype, x, y, w, h, label) -> pObject 
10156   
10157          Creates a choice object. 
10158   
10159          @param choicetype : type of choice object to be created 
10160          @param x : horizontal position of choice (upper-left corner) 
10161          @param x : vertical position of choice (upper-left corner) 
10162          @param w : width of choice in pixels 
10163          @param h : height of choice in pixels 
10164          @param label : text label of choice 
10165      """ 
10166   
10167      _fl_create_choice = cfuncproto( 
10168              load_so_libforms(), "fl_create_choice", 
10169              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
10170              FL_Coord, STRING], 
10171              """FL_OBJECT * fl_create_choice(int type, FL_Coord x, FL_Coord y, 
10172                 FL_Coord w, FL_Coord h, const char * label) 
10173              """) 
10174      check_admitted_listvalues(choicetype, CHOICETYPE_list) 
10175      ichoicetype = convert_to_int(choicetype) 
10176      ix = convert_to_FL_Coord(x) 
10177      iy = convert_to_FL_Coord(y) 
10178      iw = convert_to_FL_Coord(w) 
10179      ih = convert_to_FL_Coord(h) 
10180      slabel = convert_to_string(label) 
10181      keep_elem_refs(choicetype, x, y, w, h, label, ichoicetype, ix, iy, 
10182                     iw, ih, slabel) 
10183      retval = _fl_create_choice(ichoicetype, ix, iy, iw, ih, slabel) 
10184      return retval 
10185   
10186   
10187 -def fl_add_choice(choicetype, x, y, w, h, label): 
10188      """ 
10189          fl_add_choice(choicetype, x, y, w, h, label) -> pObject 
10190   
10191          Adds a choice object. 
10192   
10193          @param choicetype : type of choice object to be added 
10194          @param x : horizontal position of choice (upper-left corner) 
10195          @param x : vertical position of choice (upper-left corner) 
10196          @param w : width of choice in pixels 
10197          @param h : height of choice in pixels 
10198          @param label : text label of choice 
10199      """ 
10200   
10201      _fl_add_choice = cfuncproto( 
10202              load_so_libforms(), "fl_add_choice", 
10203              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
10204              FL_Coord, STRING], 
10205              """FL_OBJECT * fl_add_choice(int type, FL_Coord x, FL_Coord y, 
10206                 FL_Coord w, FL_Coord h, const char * label)  DEPRECATED 
10207              """) 
10208      check_admitted_listvalues(choicetype, CHOICETYPE_list) 
10209      ichoicetype = convert_to_int(choicetype) 
10210      ix = convert_to_FL_Coord(x) 
10211      iy = convert_to_FL_Coord(y) 
10212      iw = convert_to_FL_Coord(w) 
10213      ih = convert_to_FL_Coord(h) 
10214      slabel = convert_to_string(label) 
10215      keep_elem_refs(choicetype, x, y, w, h, label, ichoicetype, ix, iy, 
10216                     iw, ih, slabel) 
10217      retval = _fl_add_choice(ichoicetype, ix, iy, iw, ih, slabel) 
10218      return retval 
10219   
10220   
10221 -def fl_clear_choice(pObject): 
10222      """ 
10223          fl_clear_choice(pObject) 
10224   
10225          Clears the choice object. 
10226   
10227          @param pObject : pointer to chioce object 
10228      """ 
10229   
10230      _fl_clear_choice = cfuncproto( 
10231              load_so_libforms(), "fl_clear_choice", 
10232              None, [cty.POINTER(FL_OBJECT)], 
10233              """void fl_clear_choice(FL_OBJECT * ob)    DEPRECATED 
10234              """) 
10235      keep_elem_refs(pObject) 
10236      _fl_clear_choice(pObject) 
10237   
10238   
10239 -def fl_addto_choice(pObject, choicetxt): 
10240      """ 
10241          fl_addto_choice(pObject, choicetxt) -> num. 
10242   
10243          Adds a single or multiple (delimited by '|') item(s) to a choice. 
10244   
10245          @param pObject : pointer to choice object 
10246          @param choicetxt : text of item(s) to be added 
10247      """ 
10248   
10249      _fl_addto_choice = cfuncproto( 
10250              load_so_libforms(), "fl_addto_choice", 
10251              cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 
10252              """int fl_addto_choice(FL_OBJECT * ob, const char * str)    DEPRECATED 
10253              """) 
10254      warn_deprecated_function() 
10255      schoicetxt = convert_to_string(choicetxt) 
10256      keep_elem_refs(pObject, choicetxt, schoicetxt) 
10257      retval = _fl_addto_choice(pObject, schoicetxt) 
10258      return retval 
10259   
10260   
10261 -def fl_replace_choice(pObject, itemnum, choicetxt): 
10262      """ 
10263          fl_replace_choice(pObject, itemnum, choicetxt) 
10264   
10265          Replaces a line to the choice item. 
10266   
10267          @param pObject : pointer to choice object 
10268          @param itemnum : item number to be replaced 
10269          @param choicetxt : text of item to replace 
10270      """ 
10271   
10272      _fl_replace_choice = cfuncproto( 
10273              load_so_libforms(), "fl_replace_choice", 
10274              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
10275              """void fl_replace_choice(FL_OBJECT * ob, int numb, 
10276                 const char * str)    DEPRECATED 
10277              """) 
10278      iitemnum = convert_to_int(itemnum) 
10279      schoicetxt = convert_to_string(choicetxt) 
10280      keep_elem_refs(pObject, itemnum, choicetxt, iitemnum, schoicetxt) 
10281      _fl_replace_choice(pObject, iitemnum, schoicetxt) 
10282   
10283   
10284 -def fl_delete_choice(pObject, itemnum): 
10285      """ 
10286          fl_delete_choice(pObject, itemnum) 
10287   
10288          Removes a line from the choice item. 
10289   
10290          @param pObject : pointer to choice object 
10291          @param itemnum : item number 
10292      """ 
10293   
10294      _fl_delete_choice = cfuncproto( 
10295              load_so_libforms(), "fl_delete_choice", 
10296              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10297              """void fl_delete_choice(FL_OBJECT * ob, int numb)    DEPRECATED 
10298              """) 
10299      iitemnum = convert_to_int(itemnum) 
10300      keep_elem_refs(pObject, itemnum, iitemnum) 
10301      _fl_delete_choice(pObject, iitemnum) 
10302   
10303   
10304 -def fl_set_choice(pObject, choice): 
10305      """ 
10306          fl_set_choice(pObject, choice) 
10307   
10308          Sets the number of the choice. 
10309   
10310          @param pObject : pointer to choice object 
10311          @param choice : choice number 
10312      """ 
10313   
10314      _fl_set_choice = cfuncproto( 
10315              load_so_libforms(), "fl_set_choice", 
10316              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10317              """void fl_set_choice(FL_OBJECT * ob, int choice)    DEPRECATED 
10318              """) 
10319      ichoice = convert_to_int(choice) 
10320      keep_elem_refs(pObject, choice, ichoice) 
10321      _fl_set_choice(pObject, ichoice) 
10322   
10323   
10324 -def fl_set_choice_text(pObject, choicetxt): 
10325      """ 
10326          fl_set_choice_text(pObject, choicetxt) 
10327   
10328          Sets the choice using choice text. 
10329   
10330          @param pObject : pointer to choice object 
10331          @param choicetxt : text of choice 
10332      """ 
10333   
10334      _fl_set_choice_text = cfuncproto( 
10335              load_so_libforms(), "fl_set_choice_text", 
10336              None, [cty.POINTER(FL_OBJECT), STRING], 
10337              """void fl_set_choice_text(FL_OBJECT * ob, const char * txt)    DEPRECATED 
10338              """) 
10339      schoicetxt = convert_to_string(choicetxt) 
10340      keep_elem_refs(pObject, choicetxt, schoicetxt) 
10341      _fl_set_choice_text(pObject, schoicetxt) 
10342   
10343   
10344 -def fl_get_choice(pObject): 
10345      """ 
10346          fl_get_choice(pObject) -> num. 
10347   
10348          Returns the number of the choice. 
10349   
10350          @param pObject : pointer to choice object 
10351      """ 
10352   
10353      _fl_get_choice = cfuncproto( 
10354              load_so_libforms(), "fl_get_choice", 
10355              cty.c_int, [cty.POINTER(FL_OBJECT)], 
10356              """int fl_get_choice(FL_OBJECT * ob)    DEPRECATED 
10357              """) 
10358      keep_elem_refs(pObject) 
10359      retval = _fl_get_choice(pObject) 
10360      return retval 
10361   
10362   
10363 -def fl_get_choice_item_text(pObject, n): 
10364      """ fl_get_choice_item_text(pObject, n) -> text string 
10365      """ 
10366   
10367      _fl_get_choice_item_text = cfuncproto( 
10368              load_so_libforms(), "fl_get_choice_item_text", 
10369              STRING, [cty.POINTER(FL_OBJECT), cty.c_int], 
10370              """const char * fl_get_choice_item_text(FL_OBJECT * ob, int n)    DEPRECATED 
10371              """) 
10372      inum = convert_to_int(n) 
10373      keep_elem_refs(pObject, n, inum) 
10374      retval = _fl_get_choice_item_text(pObject, inum) 
10375      return retval 
10376   
10377   
10378 -def fl_get_choice_maxitems(pObject): 
10379      """ fl_get_choice_maxitems(pObject) -> items num. 
10380      """ 
10381   
10382      _fl_get_choice_maxitems = cfuncproto( 
10383              load_so_libforms(), "fl_get_choice_maxitems", 
10384              cty.c_int, [cty.POINTER(FL_OBJECT)], 
10385              """int fl_get_choice_maxitems(FL_OBJECT * ob)    DEPRECATED 
10386              """) 
10387      keep_elem_refs(pObject) 
10388      retval = _fl_get_choice_maxitems(pObject) 
10389      return retval 
10390   
10391   
10392 -def fl_get_choice_text(pObject): 
10393      """ 
10394          fl_get_choice_text(pObject) -> text string 
10395   
10396          Returns the text of the choice. 
10397   
10398          @param pObject : pointer to choice object 
10399      """ 
10400   
10401      _fl_get_choice_text = cfuncproto( 
10402              load_so_libforms(), "fl_get_choice_text", 
10403              STRING, [cty.POINTER(FL_OBJECT)], 
10404              """const char * fl_get_choice_text(FL_OBJECT * ob)    DEPRECATED 
10405              """) 
10406      keep_elem_refs(pObject) 
10407      retval = _fl_get_choice_text(pObject) 
10408      return retval 
10409   
10410   
10411 -def fl_set_choice_fontsize(pObject, size): 
10412      """ 
10413          fl_set_choice_fontsize(pObject, size) 
10414   
10415          Sets the font size inside the choice. 
10416   
10417          @param pObject : pointer to choice object 
10418          @param size : font size of choice to be set 
10419      """ 
10420   
10421      _fl_set_choice_fontsize = cfuncproto( 
10422              load_so_libforms(), "fl_set_choice_fontsize", 
10423              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10424              """void fl_set_choice_fontsize(FL_OBJECT * ob, int size) 
10425              """) 
10426      isize = convert_to_int(size) 
10427      keep_elem_refs(pObject, size, isize) 
10428      _fl_set_choice_fontsize(pObject, isize) 
10429   
10430   
10431 -def fl_set_choice_fontstyle(pObject, style): 
10432      """ 
10433          fl_set_choice_fontstyle(pObject, style) 
10434   
10435          Sets the font style inside the choice. 
10436   
10437          @param pObject : pointer to choice object 
10438          @param style : font style of choice to be set 
10439      """ 
10440   
10441      _fl_set_choice_fontstyle = cfuncproto( 
10442              load_so_libforms(), "fl_set_choice_fontstyle", 
10443              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10444              """void fl_set_choice_fontstyle(FL_OBJECT * ob, int style) 
10445              """) 
10446      istyle = convert_to_int(style) 
10447      keep_elem_refs(pObject, style, istyle) 
10448      _fl_set_choice_fontstyle(pObject, istyle) 
10449   
10450   
10451 -def fl_set_choice_align(pObject, align): 
10452      """ 
10453          fl_set_choice_align(pObject, align) 
10454   
10455          Sets alignment of text inside the choice. 
10456   
10457          @param pObject : pointer to choice object 
10458          @param align : alignment of choice text to be set 
10459      """ 
10460   
10461      _fl_set_choice_align = cfuncproto( 
10462              load_so_libforms(), "fl_set_choice_align", 
10463              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10464              """void fl_set_choice_align(FL_OBJECT * ob, int align) 
10465              """) 
10466      ialign = convert_to_int(align) 
10467      keep_elem_refs(pObject, align, ialign) 
10468      _fl_set_choice_align(pObject, ialign) 
10469   
10470   
10471 -def fl_get_choice_item_mode(pObject, item): 
10472      """ fl_get_choice_item_mode(pObject, item) -> mode num. 
10473      """ 
10474   
10475      _fl_get_choice_item_mode = cfuncproto( 
10476              load_so_libforms(), "fl_get_choice_item_mode", 
10477              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
10478              """int fl_get_choice_item_mode(FL_OBJECT * ob, int item)    DEPRECATED 
10479              """) 
10480      iitem = convert_to_int(item) 
10481      keep_elem_refs(pObject, item, iitem) 
10482      retval = _fl_get_choice_item_mode(pObject, iitem) 
10483      return retval 
10484   
10485   
10486 -def fl_set_choice_item_mode(pObject, itemnum, mode): 
10487      """ 
10488          fl_set_choice_item_mode(pObject, itemnum, mode) 
10489   
10490          Sets the mode of an item in a choice object. 
10491   
10492          @param pObject : pointer to choice object 
10493          @param itemnum : item number whose mode is to be set 
10494          @param mode : mode of item 
10495      """ 
10496   
10497      _fl_set_choice_item_mode = cfuncproto( 
10498              load_so_libforms(), "fl_set_choice_item_mode", 
10499              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_uint], 
10500              """void fl_set_choice_item_mode(FL_OBJECT * ob, int item, 
10501                 unsigned int mode) 
10502              """) 
10503      iitemnum = convert_to_int(itemnum) 
10504      uimode = convert_to_uint(mode) 
10505      keep_elem_refs(pObject, itemnum, mode, iitemnum, uimode) 
10506      _fl_set_choice_item_mode(pObject, iitemnum, uimode) 
10507   
10508   
10509 -def fl_set_choice_item_shortcut(pObject, item, sctext): 
10510      """ fl_set_choice_item_shortcut(pObject, item, sstext) 
10511      """ 
10512   
10513      _fl_set_choice_item_shortcut = cfuncproto( 
10514              load_so_libforms(), "fl_set_choice_item_shortcut", 
10515              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
10516              """void fl_set_choice_item_shortcut(FL_OBJECT * ob, int item, 
10517                 const char * sc) 
10518              """) 
10519      iitem = convert_to_int(item) 
10520      ssctext = convert_to_string(sctext) 
10521      keep_elem_refs(pObject, item, sctext, iitem, ssctext) 
10522      _fl_set_choice_item_shortcut(pObject, iitem, ssctext) 
10523   
10524   
10525 -def fl_set_choice_entries(pObject, pPopupEntry): 
10526      """ fl_set_choice_entries(pObject, pPopupEntry) -> num. 
10527      """ 
10528   
10529      _fl_set_choice_entries = cfuncproto( 
10530              load_so_libforms(), "fl_set_choice_entries", 
10531              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_PUP_ENTRY)], 
10532              """int fl_set_choice_entries(FL_OBJECT * ob, FL_PUP_ENTRY * ent)    DEPRECATED 
10533              """) 
10534      keep_elem_refs(pObject, pPopupEntry) 
10535      retval = _fl_set_choice_entries(pObject, pPopupEntry) 
10536      return retval 
10537   
10538   
10539 -def fl_set_choice_notitle(pObject, n): 
10540      """ fl_set_choice_notitle(pObject, n) -> num. 
10541      """ 
10542   
10543      _fl_set_choice_notitle = cfuncproto( 
10544              load_so_libforms(), "fl_set_choice_notitle", 
10545              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
10546              """int fl_set_choice_notitle(FL_OBJECT * ob, int n) 
10547              """) 
10548      inum = convert_to_int(n) 
10549      keep_elem_refs(pObject, n, inum) 
10550      retval = _fl_set_choice_notitle(pObject, inum) 
10551      return retval 
10552   
10553   
10554   
10555  ################################# 
10556  # forms.h (clipbd.h) 
10557  # prototypes for clipboard stuff 
10558  ################################# 
10559   
10560  FL_LOSE_SELECTION_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), 
10561                                       cty.c_long) 
10562  FL_LOSE_SELECTION_CALLBACK = FL_LOSE_SELECTION_CB 
10563   
10564 -def fl_stuff_clipboard(pObject, clipbdtype, data, size, py_LoseSelectionCb): 
10565      """ fl_stuff_clipboard(pObject, clipbdtype, data, size, py_LoseSelectionCb) -> num. 
10566      """ 
10567   
10568      _fl_stuff_clipboard = cfuncproto( 
10569              load_so_libforms(), "fl_stuff_clipboard", 
10570              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_long, cty.c_void_p, 
10571              cty.c_long, FL_LOSE_SELECTION_CB], 
10572              """int fl_stuff_clipboard(FL_OBJECT * ob, long int type, 
10573                 const char * data, long int size, 
10574                 FL_LOSE_SELECTION_CB lose_callback) 
10575              """) 
10576      lclipbdtype = convert_to_long(clipbdtype)       # type is not used 
10577      lsize = convert_to_long(size) 
10578      c_LoseSelectionCb = FL_LOSE_SELECTION_CB(py_LoseSelectionCb) 
10579      keep_cfunc_refs(c_LoseSelectionCb, py_LoseSelectionCb) 
10580      keep_elem_refs(pObject, clipbdtype, data, size, lclipbdtype, lsize) 
10581      retval = _fl_stuff_clipboard(pObject, lclipbdtype, data, lsize, 
10582                                   c_LoseSelectionCb) 
10583      return retval 
10584   
10585   
10586  FL_SELECTION_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), 
10587                                  cty.c_long, cty.c_void_p, cty.c_long) 
10588  FL_SELECTION_CALLBACK = FL_SELECTION_CB 
10589   
10590 -def fl_request_clipboard(pObject, clipbdtype, py_SelectionCb): 
10591      """ fl_request_clipboard(pObject, clipbdtype, py_SelectionCb) -> num. 
10592      """ 
10593   
10594      _fl_request_clipboard = cfuncproto( 
10595              load_so_libforms(), "fl_request_clipboard", 
10596              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_long, FL_SELECTION_CB], 
10597              """int fl_request_clipboard(FL_OBJECT * ob, long int type, 
10598                 FL_SELECTION_CB got_it_callback) 
10599              """) 
10600      lclipbdtype = convert_to_long(clipbdtype)       # type is not used 
10601      c_SelectionCb = FL_SELECTION_CB(py_SelectionCb) 
10602      keep_cfunc_refs(c_SelectionCb, py_SelectionCb) 
10603      keep_elem_refs(pObject, clipbdtype, lclipbdtype) 
10604      retval = _fl_request_clipboard(pObject, lclipbdtype, c_SelectionCb) 
10605      return retval 
10606   
10607   
10608   
10609  ################################# 
10610  # forms.h (clock.h) 
10611  ################################# 
10612   
10613   
10614 -def fl_create_clock(clocktype, x, y, w, h, label): 
10615      """ 
10616          fl_create_clock(clocktype, x, y, w, h, label) -> pObject 
10617   
10618          Creates a clock object. 
10619   
10620          @param clocktype : type of clock object to be created 
10621          @param x : horizontal position of clock (upper-left corner) 
10622          @param x : vertical position of clock (upper-left corner) 
10623          @param w : width of clock in pixels 
10624          @param h : height of clock in pixels 
10625          @param label : text label of clock 
10626      """ 
10627   
10628      _fl_create_clock = cfuncproto( 
10629              load_so_libforms(), "fl_create_clock", 
10630              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
10631              FL_Coord, STRING], 
10632              """FL_OBJECT * fl_create_clock(int type, FL_Coord x, FL_Coord y, 
10633                 FL_Coord w, FL_Coord h, const char * s) 
10634              """) 
10635      check_admitted_listvalues(clocktype, CLOCKTYPE_list) 
10636      iclocktype = convert_to_int(clocktype) 
10637      ix = convert_to_FL_Coord(x) 
10638      iy = convert_to_FL_Coord(y) 
10639      iw = convert_to_FL_Coord(w) 
10640      ih = convert_to_FL_Coord(h) 
10641      slabel = convert_to_string(label) 
10642      keep_elem_refs(clocktype, x, y, w, h, label, iclocktype, ix, iy, 
10643                     iw, ih, slabel) 
10644      retval = _fl_create_clock(iclocktype, ix, iy, iw, ih, slabel) 
10645      return retval 
10646   
10647   
10648 -def fl_add_clock(clocktype, x, y, w, h, label): 
10649      """ 
10650          fl_add_clock(clocktype, x, y, w, h, label) -> pObject 
10651   
10652          Adds a clock object. 
10653   
10654          @param clocktype : type of clock object to be added 
10655          @param x : horizontal position of clock (upper-left corner) 
10656          @param x : vertical position of clock (upper-left corner) 
10657          @param w : width of clock in pixels 
10658          @param h : height of clock in pixels 
10659          @param label : text label of clock 
10660      """ 
10661   
10662      _fl_add_clock = cfuncproto( 
10663              load_so_libforms(), "fl_add_clock", 
10664              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
10665              FL_Coord, STRING], 
10666              """FL_OBJECT * fl_add_clock(int type, FL_Coord x, FL_Coord y, 
10667                 FL_Coord w, FL_Coord h, const char * s) 
10668              """) 
10669      check_admitted_listvalues(clocktype, CLOCKTYPE_list) 
10670      iclocktype = convert_to_int(clocktype) 
10671      ix = convert_to_FL_Coord(x) 
10672      iy = convert_to_FL_Coord(y) 
10673      iw = convert_to_FL_Coord(w) 
10674      ih = convert_to_FL_Coord(h) 
10675      slabel = convert_to_string(label) 
10676      keep_elem_refs(clocktype, x, y, w, h, label, iclocktype, ix, iy, 
10677                     iw, ih, slabel) 
10678      retval = _fl_add_clock(iclocktype, ix, iy, iw, ih, slabel) 
10679      return retval 
10680   
10681   
10682  #def fl_get_clock(pObject, hr, mn, sec)       *API change* 
10683 -def fl_get_clock(pObject): 
10684      """ fl_get_clock(pObject) -> hr, mn, sec 
10685   
10686          Returns time values from a clock object. 
10687   
10688          @param pObject : pointer to clock object 
10689      """ 
10690   
10691      _fl_get_clock = cfuncproto( 
10692              load_so_libforms(), "fl_get_clock", 
10693              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
10694              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 
10695              """void fl_get_clock(FL_OBJECT * ob, int * h, int * m, int * s) 
10696              """) 
10697      hr, phr = make_int_and_pointer() 
10698      mn, pmn = make_int_and_pointer() 
10699      sec, psec = make_int_and_pointer() 
10700      keep_elem_refs(pObject, hr, mn, sec, phr, pmn, psec) 
10701      _fl_get_clock(pObject, phr, pmn, psec) 
10702      return hr, mn, sec 
10703   
10704   
10705 -def fl_set_clock_adjustment(pObject, offset): 
10706      """ fl_set_clock_adjustment(pObject, offset) -> num. 
10707      """ 
10708   
10709      _fl_set_clock_adjustment = cfuncproto( 
10710              load_so_libforms(), "fl_set_clock_adjustment", 
10711              cty.c_long, [cty.POINTER(FL_OBJECT), cty.c_long], 
10712              """long int fl_set_clock_adjustment(FL_OBJECT * ob, 
10713                 long int offset) 
10714              """) 
10715      loffset = convert_to_long(offset) 
10716      keep_elem_refs(pObject, offset, loffset) 
10717      retval = _fl_set_clock_adjustment(pObject, loffset) 
10718      return retval 
10719   
10720   
10721 -def fl_set_clock_ampm(pObject, y): 
10722      """ fl_set_clock_ampm(pObject, y) 
10723      """ 
10724   
10725      _fl_set_clock_ampm = cfuncproto( 
10726              load_so_libforms(), "fl_set_clock_ampm", 
10727              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10728              """void fl_set_clock_ampm(FL_OBJECT * ob, int y) 
10729              """) 
10730      iy = convert_to_int(y) 
10731      keep_elem_refs(pObject, y, iy) 
10732      _fl_set_clock_ampm(pObject, iy) 
10733   
10734   
10735   
10736  ###################### 
10737  # forms.h (counter.h) 
10738  ###################### 
10739   
10740  # Routines 
10741   
10742 -def fl_create_counter(countertype, x, y, w, h, label): 
10743      """ 
10744          fl_create_counter(countertype, x, y, w, h, label) -> pObject 
10745   
10746          Creates a counter object. 
10747   
10748          @param countertype : type of counter object to be created 
10749          @param x : horizontal position of counter (upper-left corner) 
10750          @param x : vertical position of counter (upper-left corner) 
10751          @param w : width of counter in pixels 
10752          @param h : height of counter in pixels 
10753          @param label : text label of counter 
10754      """ 
10755   
10756      _fl_create_counter = cfuncproto( 
10757              load_so_libforms(), "fl_create_counter", 
10758              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
10759              FL_Coord, STRING], 
10760              """FL_OBJECT * fl_create_counter(int type, FL_Coord x, FL_Coord y, 
10761                 FL_Coord w, FL_Coord h, const char * label) 
10762              """) 
10763      check_admitted_listvalues(countertype, COUNTERTYPE_list) 
10764      icountertype = convert_to_int(countertype) 
10765      ix = convert_to_FL_Coord(x) 
10766      iy = convert_to_FL_Coord(y) 
10767      iw = convert_to_FL_Coord(w) 
10768      ih = convert_to_FL_Coord(h) 
10769      slabel = convert_to_string(label) 
10770      keep_elem_refs(countertype, x, y, w, h, label, icountertype, ix, iy, 
10771                     iw, ih, slabel) 
10772      retval = _fl_create_counter(icountertype, ix, iy, iw, ih, slabel) 
10773      return retval 
10774   
10775   
10776 -def fl_add_counter(countertype, x, y, w, h, label): 
10777      """ 
10778          fl_add_counter(countertype, x, y, w, h, label) -> pObject 
10779   
10780          Adds a counter object. 
10781   
10782          @param countertype : type of counter object to be added 
10783          @param x : horizontal position of counter (upper-left corner) 
10784          @param x : vertical position of counter (upper-left corner) 
10785          @param w : width of counter in pixels 
10786          @param h : height of counter in pixels 
10787          @param label : text label of counter 
10788      """ 
10789   
10790      _fl_add_counter = cfuncproto( 
10791              load_so_libforms(), "fl_add_counter", 
10792              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
10793              FL_Coord, STRING], 
10794              """FL_OBJECT * fl_add_counter(int type, FL_Coord x, FL_Coord y, 
10795                 FL_Coord w, FL_Coord h, const char * label) 
10796              """) 
10797      check_admitted_listvalues(countertype, COUNTERTYPE_list) 
10798      icountertype = convert_to_int(countertype) 
10799      ix = convert_to_FL_Coord(x) 
10800      iy = convert_to_FL_Coord(y) 
10801      iw = convert_to_FL_Coord(w) 
10802      ih = convert_to_FL_Coord(h) 
10803      slabel = convert_to_string(label) 
10804      keep_elem_refs(countertype, x, y, w, h, label, icountertype, ix, iy, 
10805                     iw, ih, slabel) 
10806      retval = _fl_add_counter(icountertype, ix, iy, iw, ih, slabel) 
10807      return retval 
10808   
10809   
10810 -def fl_set_counter_value(pObject, val): 
10811      """ fl_set_counter_value(pObject, val) 
10812      """ 
10813   
10814      _fl_set_counter_value = cfuncproto( 
10815              load_so_libforms(), "fl_set_counter_value", 
10816              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
10817              """void fl_set_counter_value(FL_OBJECT * ob, double val) 
10818              """) 
10819      fval = convert_to_double(val) 
10820      keep_elem_refs(pObject, val, fval) 
10821      _fl_set_counter_value(pObject, fval) 
10822   
10823   
10824 -def fl_set_counter_bounds(pObject, minbound, maxbound): 
10825      """ fl_set_counter_bounds(pObject, minbound, maxbound) 
10826      """ 
10827   
10828      _fl_set_counter_bounds = cfuncproto( 
10829              load_so_libforms(), "fl_set_counter_bounds", 
10830              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
10831              """void fl_set_counter_bounds(FL_OBJECT * ob, double min, 
10832                 double max) 
10833              """) 
10834      fminbound = convert_to_double(minbound) 
10835      fmaxbound = convert_to_double(maxbound) 
10836      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
10837      _fl_set_counter_bounds(pObject, fminbound, fmaxbound) 
10838   
10839   
10840 -def fl_set_counter_step(pObject, s, l): 
10841      """ fl_set_counter_step(pObject, s, l) 
10842      """ 
10843   
10844      _fl_set_counter_step = cfuncproto( 
10845              load_so_libforms(), "fl_set_counter_step", 
10846              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
10847              """void fl_set_counter_step(FL_OBJECT * ob, double s, double l) 
10848              """) 
10849      fs = convert_to_double(s) 
10850      fl = convert_to_double(l) 
10851      keep_elem_refs(pObject, s, l, fs, fl) 
10852      _fl_set_counter_step(pObject, fs, fl) 
10853   
10854   
10855 -def fl_set_counter_precision(pObject, prec): 
10856      """ fl_set_counter_precision(pObject, prec) 
10857      """ 
10858   
10859      _fl_set_counter_precision = cfuncproto( 
10860              load_so_libforms(), "fl_set_counter_precision", 
10861              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10862              """void fl_set_counter_precision(FL_OBJECT * ob, int prec) 
10863              """) 
10864      iprec = convert_to_int(prec) 
10865      keep_elem_refs(pObject, prec, iprec) 
10866      _fl_set_counter_precision(pObject, iprec) 
10867   
10868   
10869 -def fl_get_counter_precision(pObject): 
10870      """ fl_get_counter_precision(pObject) -> num. 
10871      """ 
10872   
10873      _fl_get_counter_precision = cfuncproto( 
10874              load_so_libforms(), "fl_get_counter_precision", 
10875              cty.c_int, [cty.POINTER(FL_OBJECT)], 
10876              """int fl_get_counter_precision(FL_OBJECT * ob) 
10877              """) 
10878      keep_elem_refs(pObject) 
10879      retval = _fl_get_counter_precision(pObject) 
10880      return retval 
10881   
10882   
10883 -def fl_set_counter_return(pObject, how): 
10884      """ fl_set_counter_return(pObject, how) 
10885      """ 
10886   
10887      _fl_set_counter_return = cfuncproto( 
10888              load_so_libforms(), "fl_set_counter_return", 
10889              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10890              """void fl_set_counter_return(FL_OBJECT * ob, int how) 
10891              """) 
10892      ihow = convert_to_int(how) 
10893      keep_elem_refs(pObject, how, ihow) 
10894      _fl_set_counter_return(pObject, ihow) 
10895   
10896   
10897 -def fl_get_counter_value(pObject): 
10898      """ fl_get_counter_value(pObject) -> num. 
10899      """ 
10900   
10901      _fl_get_counter_value = cfuncproto( 
10902              load_so_libforms(), "fl_get_counter_value", 
10903              cty.c_double, [cty.POINTER(FL_OBJECT)], 
10904              """double fl_get_counter_value(FL_OBJECT * ob) 
10905              """) 
10906      keep_elem_refs(pObject) 
10907      retval = _fl_get_counter_value(pObject) 
10908      return retval 
10909   
10910   
10911  #def fl_get_counter_bounds(pObject, minbound, maxbound)       *API change* 
10912 -def fl_get_counter_bounds(pObject): 
10913      """ fl_get_counter_bounds(pObject) -> minbound, maxbound 
10914      """ 
10915   
10916      _fl_get_counter_bounds = cfuncproto( 
10917              load_so_libforms(), "fl_get_counter_bounds", 
10918              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
10919              cty.POINTER(cty.c_double)], 
10920              """void fl_get_counter_bounds(FL_OBJECT * ob, double * min, 
10921                 double * max) 
10922              """) 
10923      minbound, pminbound = make_double_and_pointer() 
10924      maxbound, pmaxbound = make_double_and_pointer() 
10925      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
10926      _fl_get_counter_bounds(pObject, pminbound, pmaxbound) 
10927      return minbound, maxbound 
10928   
10929   
10930  #def fl_get_counter_step(pObject, s, l)       *API change* 
10931 -def fl_get_counter_step(pObject): 
10932      """ fl_get_counter_step(pObject) -> s, l 
10933      """ 
10934   
10935      _fl_get_counter_step = cfuncproto( 
10936              load_so_libforms(), "fl_get_counter_step", 
10937              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
10938              cty.POINTER(cty.c_double)], 
10939              """void fl_get_counter_step(FL_OBJECT * ob, double * s, 
10940                 double * l) 
10941              """) 
10942      s, ps = make_double_and_pointer() 
10943      l, pl = make_double_and_pointer() 
10944      keep_elem_refs(pObject, s, l, ps, pl) 
10945      _fl_get_counter_step(pObject, ps, pl) 
10946      return s, l 
10947   
10948   
10949  FL_VAL_FILTER = cty.CFUNCTYPE(STRING, cty.POINTER(FL_OBJECT), cty.c_double, \ 
10950                                cty.c_int) 
10951   
10952 -def fl_set_counter_filter(pObject, py_ValFilter): 
10953      """ fl_set_counter_filter(pObject, ValFilter) 
10954      """ 
10955   
10956      _fl_set_counter_filter = cfuncproto( 
10957              load_so_libforms(), "fl_set_counter_filter", 
10958              None, [cty.POINTER(FL_OBJECT), FL_VAL_FILTER], 
10959              """void fl_set_counter_filter(FL_OBJECT * ob, 
10960                 FL_VAL_FILTER filter) 
10961              """) 
10962      c_ValFilter = FL_VAL_FILTER(py_ValFilter) 
10963      keep_cfunc_refs(c_ValFilter, py_ValFilter) 
10964      keep_elem_refs(pObject) 
10965      _fl_set_counter_filter(pObject, c_ValFilter) 
10966   
10967   
10968  # Functions to set and get the timeout value used by the 
10969  # counter code to control modification of the counter value. 
10970   
10971 -def fl_get_counter_repeat(pObject): 
10972      """ fl_get_counter_repeat(pObject) -> num. 
10973      """ 
10974   
10975      _fl_get_counter_repeat = cfuncproto( 
10976              load_so_libforms(), "fl_get_counter_repeat", 
10977              cty.c_int, [cty.POINTER(FL_OBJECT)], 
10978              """int fl_get_counter_repeat(FL_OBJECT * ob) 
10979              """) 
10980      keep_elem_refs(pObject) 
10981      retval = _fl_get_counter_repeat(pObject) 
10982      return retval 
10983   
10984   
10985 -def fl_set_counter_repeat(pObject, msec): 
10986      """ fl_set_counter_repeat(pObject, msec) 
10987      """ 
10988   
10989      _fl_set_counter_repeat = cfuncproto( 
10990              load_so_libforms(), "fl_set_counter_repeat", 
10991              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10992              """void fl_set_counter_repeat(FL_OBJECT * ob, int millisec) 
10993              """) 
10994      imsec = convert_to_int(msec) 
10995      keep_elem_refs(pObject, msec, imsec) 
10996      _fl_set_counter_repeat(pObject, imsec) 
10997   
10998   
10999 -def fl_get_counter_min_repeat(pObject): 
11000      """ fl_get_counter_min_repeat(pObject) -> num. 
11001      """ 
11002   
11003      _fl_get_counter_min_repeat = cfuncproto( 
11004              load_so_libforms(), "fl_get_counter_min_repeat", 
11005              cty.c_int, [cty.POINTER(FL_OBJECT)], 
11006              """int fl_get_counter_min_repeat(FL_OBJECT * ob) 
11007              """) 
11008      keep_elem_refs(pObject) 
11009      retval = _fl_get_counter_min_repeat(pObject) 
11010      return retval 
11011   
11012   
11013 -def fl_set_counter_min_repeat(pObject, msec): 
11014      """ fl_set_counter_min_repeat(pObject, msec) 
11015      """ 
11016   
11017      _fl_set_counter_min_repeat = cfuncproto( 
11018              load_so_libforms(), "fl_set_counter_min_repeat", 
11019              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11020              """void fl_set_counter_min_repeat(FL_OBJECT * ob, int millisec) 
11021              """) 
11022      imsec = convert_to_int(msec) 
11023      keep_elem_refs(pObject, msec, imsec) 
11024      _fl_set_counter_min_repeat(pObject, imsec) 
11025   
11026   
11027 -def fl_get_counter_speedjump(pObject): 
11028      """ fl_get_counter_speedjump(pObject) -> num. 
11029      """ 
11030   
11031      _fl_get_counter_speedjump = cfuncproto( 
11032              load_so_libforms(), "fl_get_counter_speedjump", 
11033              cty.c_int, [cty.POINTER(FL_OBJECT)], 
11034              """int fl_get_counter_speedjump(FL_OBJECT * ob) 
11035              """) 
11036      keep_elem_refs(pObject) 
11037      retval = _fl_get_counter_speedjump(pObject) 
11038      return retval 
11039   
11040   
11041 -def fl_set_counter_speedjump(pObject, yesno): 
11042      """ fl_set_counter_speedjump(pObject, yesno) 
11043      """ 
11044   
11045      _fl_set_counter_speedjump = cfuncproto( 
11046              load_so_libforms(), "fl_set_counter_speedjump", 
11047              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11048              """void fl_set_counter_speedjump(FL_OBJECT * ob, int yes_no) 
11049              """) 
11050      iyesno = convert_to_int(yesno) 
11051      keep_elem_refs(pObject, yesno, iyesno) 
11052      _fl_set_counter_speedjump(pObject, iyesno) 
11053   
11054   
11055   
11056  ############################# 
11057  # forms.h (cursor.h) 
11058  # Cursor defs and prototypes 
11059  ############################# 
11060   
11061 -def fl_set_cursor(win, cursnum): 
11062      """ 
11063          fl_set_cursor(win, cursnum) 
11064   
11065          Set cursor for window to provided cursor number name. Name 
11066          is either the standard XC_ or Form defined 
11067   
11068          @param win : window 
11069          @param cursnum : cursor number 
11070      """ 
11071   
11072      _fl_set_cursor = cfuncproto( 
11073              load_so_libforms(), "fl_set_cursor", 
11074              None, [Window, cty.c_int], 
11075              """void fl_set_cursor(Window win, int name) 
11076              """) 
11077      ulwin = convert_to_Window(win) 
11078      icursnum = convert_to_int(cursnum) 
11079      keep_elem_refs(win, cursnum, ulwin, icursnum) 
11080      _fl_set_cursor(ulwin, icursnum) 
11081   
11082   
11083 -def fl_set_cursor_color(cursnum, fgcolr, bgcolr): 
11084      """ 
11085          fl_set_cursor_color(cursnum, fgcolr, bgcolr) 
11086   
11087          Sets foreground and background colors for cursor. 
11088   
11089          @param cursnum : cursor number 
11090          @param fgcolr : foreground color to be set 
11091          @param bgcolr : background color to be set 
11092      """ 
11093   
11094      _fl_set_cursor_color = cfuncproto( 
11095              load_so_libforms(), "fl_set_cursor_color", 
11096              None, [cty.c_int, FL_COLOR, FL_COLOR], 
11097              """void fl_set_cursor_color(int name, FL_COLOR fg, FL_COLOR bg) 
11098              """) 
11099      icursnum = convert_to_int(cursnum) 
11100      ulfgcolr = convert_to_FL_COLOR(fgcolr) 
11101      ulbgcolr = convert_to_FL_COLOR(bgcolr) 
11102      keep_elem_refs(cursnum, fgcolr, bgcolr, icursnum, ulfgcolr, ulbgcolr) 
11103      _fl_set_cursor_color(icursnum, ulfgcolr, ulbgcolr) 
11104   
11105   
11106 -def fl_create_bitmap_cursor(source, maskstr, w, h, hotx, hoty): 
11107      """ fl_create_bitmap_cursor(source, maskstr, w, h, hotx, hoty) -> num. 
11108      """ 
11109   
11110      _fl_create_bitmap_cursor = cfuncproto( 
11111              load_so_libforms(), "fl_create_bitmap_cursor", 
11112              cty.c_int, [STRING, STRING, cty.c_int, cty.c_int, cty.c_int, 
11113              cty.c_int], 
11114              """int fl_create_bitmap_cursor(const char * source, 
11115                 const char * mask, int w, int h, int hotx, int hoty) 
11116              """) 
11117      ssource = convert_to_string(source) 
11118      smaskstr = convert_to_string(maskstr) 
11119      iw = convert_to_int(w) 
11120      ih = convert_to_FL_Coord(h) 
11121      ihotx = convert_to_int(hotx) 
11122      ihoty = convert_to_int(hoty) 
11123      keep_elem_refs(source, maskstr, w, h, hotx, hoty, ssource, smaskstr, 
11124                     iw, ih, ihotx, ihoty) 
11125      retval = _fl_create_bitmap_cursor(ssource, smaskstr, iw, ih, ihotx, ihoty) 
11126      return retval 
11127   
11128   
11129 -def fl_create_animated_cursor(curnums, timeout): 
11130      """ fl_create_animated_cursor(curnums, timeout) -> num. 
11131      """ 
11132   
11133      _fl_create_animated_cursor = cfuncproto( 
11134              load_so_libforms(), "fl_create_animated_cursor", 
11135              cty.c_int, [cty.POINTER(cty.c_int), cty.c_int], 
11136              """int fl_create_animated_cursor(int * cur_names, int timeout) 
11137              """) 
11138      pcurnums = cty.cast(curnums, cty.POINTER(cty.c_int)) 
11139      #print "pcurnums", pcurnums 
11140      itimeout = convert_to_int(timeout) 
11141      keep_elem_refs(curnums, timeout, pcurnums, itimeout) 
11142      retval = _fl_create_animated_cursor(pcurnums, itimeout) 
11143      return retval 
11144   
11145   
11146 -def fl_get_cursor_byname(cursnum): 
11147      """ 
11148          fl_get_cursor_byname(cursnum) -> cursor 
11149   
11150          Return cursor corresponding to number. 
11151           
11152          @param cursnum : cursor number 
11153      """ 
11154   
11155      _fl_get_cursor_byname = cfuncproto( 
11156              load_so_libforms(), "fl_get_cursor_byname", 
11157              Cursor, [cty.c_int], 
11158              """Cursor fl_get_cursor_byname(int name) 
11159              """) 
11160      icursnum = convert_to_int(cursnum) 
11161      keep_elem_refs(cursnum, icursnum) 
11162      retval = _fl_get_cursor_byname(icursnum) 
11163      return retval 
11164   
11165   
11166 -def fl_reset_cursor(win): 
11167      """ 
11168          Reset used cursor, reverting to default one. 
11169      """ 
11170   
11171      fl_set_cursor(win, FL_DEFAULT_CURSOR) 
11172   
11173   
11174   
11175  ################### 
11176  # forms.h (dial.h) 
11177  ################### 
11178   
11179  # Routines 
11180   
11181 -def fl_create_dial(dialtype, x, y, w, h, label): 
11182      """ fl_create_dial(dialtype, x, y, w, h, label) -> pObject 
11183      """ 
11184   
11185      _fl_create_dial = cfuncproto( 
11186              load_so_libforms(), "fl_create_dial", 
11187              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
11188              FL_Coord, STRING], 
11189              """FL_OBJECT * fl_create_dial(int type, FL_Coord x, FL_Coord y, 
11190                 FL_Coord w, FL_Coord h, const char * label) 
11191              """) 
11192      check_admitted_listvalues(dialtype, DIALTYPE_list) 
11193      idialtype = convert_to_int(dialtype) 
11194      ix = convert_to_FL_Coord(x) 
11195      iy = convert_to_FL_Coord(y) 
11196      iw = convert_to_FL_Coord(w) 
11197      ih = convert_to_FL_Coord(h) 
11198      slabel = convert_to_string(label) 
11199      keep_elem_refs(dialtype, x, y, w, h, label, idialtype, ix, iy, 
11200                     iw, ih, slabel) 
11201      retval = _fl_create_dial(idialtype, ix, iy, iw, ih, slabel) 
11202      return retval 
11203   
11204   
11205 -def fl_add_dial(dialtype, x, y, w, h, label): 
11206      """ fl_add_dial(dialtype, x, y, w, h, label) -> pObject 
11207      """ 
11208   
11209      _fl_add_dial = cfuncproto( 
11210              load_so_libforms(), "fl_add_dial", 
11211              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
11212              FL_Coord, STRING], 
11213              """FL_OBJECT * fl_add_dial(int type, FL_Coord x, FL_Coord y, 
11214                 FL_Coord w, FL_Coord h, const char * label) 
11215              """) 
11216      check_admitted_listvalues(dialtype, DIALTYPE_list) 
11217      idialtype = convert_to_int(dialtype) 
11218      ix = convert_to_FL_Coord(x) 
11219      iy = convert_to_FL_Coord(y) 
11220      iw = convert_to_FL_Coord(w) 
11221      ih = convert_to_FL_Coord(h) 
11222      slabel = convert_to_string(label) 
11223      keep_elem_refs(dialtype, x, y, w, h, label, idialtype, ix, iy, 
11224                     iw, ih, slabel) 
11225      retval = _fl_add_dial(idialtype, ix, iy, iw, ih, slabel) 
11226      return retval 
11227   
11228   
11229 -def fl_set_dial_value(pObject, val): 
11230      """ fl_set_dial_value(pObject, val) 
11231      """ 
11232   
11233      _fl_set_dial_value = cfuncproto( 
11234              load_so_libforms(), "fl_set_dial_value", 
11235              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
11236              """void fl_set_dial_value(FL_OBJECT * ob, double val) 
11237              """) 
11238      fval = convert_to_double(val) 
11239      keep_elem_refs(pObject, val, fval) 
11240      _fl_set_dial_value(pObject, fval) 
11241   
11242   
11243 -def fl_get_dial_value(pObject): 
11244      """ fl_get_dial_value(pObject) -> num. 
11245      """ 
11246   
11247      _fl_get_dial_value = cfuncproto( 
11248              load_so_libforms(), "fl_get_dial_value", 
11249              cty.c_double, [cty.POINTER(FL_OBJECT)], 
11250              """double fl_get_dial_value(FL_OBJECT * ob) 
11251              """) 
11252      keep_elem_refs(pObject) 
11253      retval = _fl_get_dial_value(pObject) 
11254      return retval 
11255   
11256   
11257 -def fl_set_dial_bounds(pObject, minbound, maxbound): 
11258      """ fl_set_dial_bounds(pObject, minbound, maxbound) 
11259      """ 
11260   
11261      _fl_set_dial_bounds = cfuncproto( 
11262              load_so_libforms(), "fl_set_dial_bounds", 
11263              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
11264              """void fl_set_dial_bounds(FL_OBJECT * ob, double min, 
11265                 double max) 
11266              """) 
11267      fminbound = convert_to_double(minbound) 
11268      fmaxbound = convert_to_double(maxbound) 
11269      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
11270      _fl_set_dial_bounds(pObject, fminbound, fmaxbound) 
11271   
11272   
11273  #def fl_get_dial_bounds(pObject, minbound, maxbound)       *API change* 
11274 -def fl_get_dial_bounds(pObject): 
11275      """ fl_get_dial_bounds(pObject) -> minbound, maxbound 
11276      """ 
11277   
11278      _fl_get_dial_bounds = cfuncproto( 
11279              load_so_libforms(), "fl_get_dial_bounds", 
11280              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
11281              cty.POINTER(cty.c_double)], 
11282              """void fl_get_dial_bounds(FL_OBJECT * ob, double * min, 
11283                 double * max) 
11284              """) 
11285      minbound, pminbound = make_double_and_pointer() 
11286      maxbound, pmaxbound = make_double_and_pointer() 
11287      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
11288      _fl_get_dial_bounds(pObject, pminbound, pmaxbound) 
11289      return minbound, maxbound 
11290   
11291   
11292 -def fl_set_dial_step(pObject, value): 
11293      """ fl_set_dial_step(pObject, value) 
11294      """ 
11295   
11296      _fl_set_dial_step = cfuncproto( 
11297              load_so_libforms(), "fl_set_dial_step", 
11298              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
11299              """void fl_set_dial_step(FL_OBJECT * ob, double value) 
11300              """) 
11301      fvalue = convert_to_double(value) 
11302      keep_elem_refs(pObject, value, fvalue) 
11303      _fl_set_dial_step(pObject, fvalue) 
11304   
11305   
11306 -def fl_set_dial_return(pObject, value): 
11307      """ fl_set_dial_return(pObject, value) 
11308      """ 
11309   
11310      _fl_set_dial_return = cfuncproto( 
11311              load_so_libforms(), "fl_set_dial_return", 
11312              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11313              """void fl_set_dial_return(FL_OBJECT * ob, int value) 
11314              """) 
11315      ivalue = convert_to_int(value) 
11316      keep_elem_refs(pObject, value, ivalue) 
11317      _fl_set_dial_return(pObject, ivalue) 
11318   
11319   
11320 -def fl_set_dial_angles(pObject, angmin, angmax): 
11321      """ fl_set_dial_angles(pObject, angmin, angmax) 
11322      """ 
11323   
11324      _fl_set_dial_angles = cfuncproto( 
11325              load_so_libforms(), "fl_set_dial_angles", 
11326              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
11327              """void fl_set_dial_angles(FL_OBJECT * ob, double amin, 
11328                 double amax) 
11329              """) 
11330      fangmin = convert_to_double(angmin) 
11331      fangmax = convert_to_double(angmax) 
11332      keep_elem_refs(pObject, angmin, angmax, fangmin, fangmax) 
11333      _fl_set_dial_angles(pObject, fangmin, fangmax) 
11334   
11335   
11336 -def fl_set_dial_cross(pObject, flag): 
11337      """ fl_set_dial_cross(pObject, flag) 
11338      """ 
11339   
11340      _fl_set_dial_cross = cfuncproto( 
11341              load_so_libforms(), "fl_set_dial_cross", 
11342              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11343              """void fl_set_dial_cross(FL_OBJECT * ob, int flag) 
11344              """) 
11345      iflag = convert_to_int(flag) 
11346      keep_elem_refs(pObject, flag, iflag) 
11347      _fl_set_dial_cross(pObject, iflag) 
11348   
11349   
11350  fl_set_dial_crossover = fl_set_dial_cross 
11351   
11352   
11353 -def fl_set_dial_direction(pObject, directn): 
11354      """ fl_set_dial_direction(pObject, directn) 
11355      """ 
11356   
11357      _fl_set_dial_direction = cfuncproto( 
11358              load_so_libforms(), "fl_set_dial_direction", 
11359              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11360              """void fl_set_dial_direction(FL_OBJECT * ob, int dir) 
11361              """) 
11362      idirectn = convert_to_int(directn) 
11363      keep_elem_refs(pObject, directn, idirectn) 
11364      _fl_set_dial_direction(pObject, idirectn) 
11365   
11366   
11367   
11368  ############################################ 
11369  # forms.h (filesys.h) 
11370  # Convenience functions to read a directory 
11371  ############################################ 
11372   
11373  # read dir with pattern filtering. All dirs read might be cached. 
11374  # must not change dirlist in anyway. 
11375   
11376  #def fl_get_dirlist(directory, pattern, n, rescan)       *API change* 
11377 -def fl_get_dirlist(directory, pattern, rescan): 
11378      """ fl_get_dirlist(directory, pattern, rescan) -> pDirList, n 
11379      """ 
11380   
11381      _fl_get_dirlist = cfuncproto( 
11382              load_so_libforms(), "fl_get_dirlist", 
11383              cty.POINTER(FL_Dirlist), [STRING, STRING, cty.POINTER(cty.c_int), 
11384              cty.c_int], 
11385              """const char * fl_get_dirlist(const char * dir, 
11386                 const char * pattern, int * n, int rescan) 
11387              """) 
11388      sdirectory = convert_to_string(directory) 
11389      spattern = convert_to_string(pattern) 
11390      n, pn = make_int_and_pointer() 
11391      irescan = convert_to_int(rescan) 
11392      keep_elem_refs(directory, pattern, n, rescan, sdirectory, spattern, 
11393                     pn, irescan) 
11394      retval = _fl_get_dirlist(sdirectory, spattern, pn, irescan) 
11395      return retval, n 
11396   
11397   
11398  FL_DIRLIST_FILTER = cty.CFUNCTYPE(cty.c_int, STRING, cty.c_int) 
11399   
11400 -def fl_set_dirlist_filter(py_DirFilter): 
11401      """ fl_set_dirlist_filter(py_DirFilter) -> dirlist_filter func. 
11402      """ 
11403   
11404      _fl_set_dirlist_filter = cfuncproto( 
11405              load_so_libforms(), "fl_set_dirlist_filter", 
11406              FL_DIRLIST_FILTER, [FL_DIRLIST_FILTER], 
11407              """FL_DIRLIST_FILTER fl_set_dirlist_filter( \ 
11408                 FL_DIRLIST_FILTER filter) 
11409              """) 
11410      c_DirFilter = FL_DIRLIST_FILTER(py_DirFilter) 
11411      keep_cfunc_refs(c_DirFilter, py_DirFilter) 
11412      retval = _fl_set_dirlist_filter(c_DirFilter) 
11413      return retval 
11414   
11415   
11416 -def fl_set_dirlist_sort(method): 
11417      """ fl_set_dirlist_sort(method) -> num. 
11418      """ 
11419   
11420      _fl_set_dirlist_sort = cfuncproto( 
11421              load_so_libforms(), "fl_set_dirlist_sort", 
11422              cty.c_int, [cty.c_int], 
11423              """int fl_set_dirlist_sort(int method) 
11424              """) 
11425      imethod = convert_to_int(method) 
11426      keep_elem_refs(method, imethod) 
11427      retval = _fl_set_dirlist_sort(imethod) 
11428      return retval 
11429   
11430   
11431 -def fl_set_dirlist_filterdir(yes): 
11432      """ fl_set_dirlist_filterdir(yes) -> num. 
11433      """ 
11434   
11435      _fl_set_dirlist_filterdir = cfuncproto( 
11436              load_so_libforms(), "fl_set_dirlist_filterdir", 
11437              cty.c_int, [cty.c_int], 
11438              """int fl_set_dirlist_filterdir(int yes) 
11439              """) 
11440      iyes = convert_to_int(yes) 
11441      keep_elem_refs(yes, iyes) 
11442      retval = _fl_set_dirlist_filterdir(iyes) 
11443      return retval 
11444   
11445   
11446 -def fl_free_dirlist(pDirList): 
11447      """ fl_free_dirlist(pDirList) 
11448      """ 
11449   
11450      _fl_free_dirlist = cfuncproto( 
11451              load_so_libforms(), "fl_free_dirlist", 
11452              None, [cty.POINTER(FL_Dirlist)], 
11453              """void fl_free_dirlist(FL_Dirlist * dl) 
11454              """) 
11455      keep_elem_refs(pDirList) 
11456      _fl_free_dirlist(pDirList) 
11457   
11458   
11459  # Free all directory caches 
11460   
11461 -def fl_free_all_dirlist(): 
11462      """ fl_free_all_dirlist() 
11463      """ 
11464   
11465      _fl_free_all_dirlist = cfuncproto( 
11466              load_so_libforms(), "fl_free_all_dirlist", 
11467              None, [], 
11468              """void fl_free_all_dirlist() 
11469              """) 
11470      _fl_free_all_dirlist() 
11471   
11472   
11473 -def fl_is_valid_dir(name): 
11474      """ fl_is_valid_dir(name) -> num. 
11475      """ 
11476   
11477      _fl_is_valid_dir = cfuncproto( 
11478              load_so_libforms(), "fl_is_valid_dir", 
11479              cty.c_int, [STRING], 
11480              """int fl_is_valid_dir(const char * name) 
11481              """) 
11482      sname = convert_to_string(name) 
11483      keep_elem_refs(name, sname) 
11484      retval = _fl_is_valid_dir(sname) 
11485      return retval 
11486   
11487   
11488 -def fl_fmtime(timestr): 
11489      """ fl_fmtime(timestr) -> num. 
11490      """ 
11491   
11492      _fl_fmtime = cfuncproto( 
11493              load_so_libforms(), "fl_fmtime", 
11494              cty.c_ulong, [STRING], 
11495              """long unsigned int fl_fmtime(const char * s) 
11496              """) 
11497      stimestr = convert_to_string(timestr) 
11498      keep_elem_refs(timestr, stimestr) 
11499      retval = _fl_fmtime(stimestr) 
11500      return retval 
11501   
11502   
11503 -def fl_fix_dirname(directory): 
11504      """ fl_fix_dirname(directory) -> dirname string 
11505      """ 
11506   
11507      _fl_fix_dirname = cfuncproto( 
11508              load_so_libforms(), "fl_fix_dirname", 
11509              STRING, [STRING], 
11510              """char * fl_fix_dirname(char * dir) 
11511              """) 
11512      sdirectory = convert_to_string(directory) 
11513      keep_elem_refs(directory, sdirectory) 
11514      retval = _fl_fix_dirname(sdirectory) 
11515      return retval 
11516   
11517   
11518   
11519  ################### 
11520  # forms.h (flps.h) 
11521  ################### 
11522   
11523  # postscript stuff 
11524   
11525 -def flps_init(): 
11526      """ flps_init() -> flps_control class 
11527      """ 
11528   
11529      _flps_init = cfuncproto( 
11530              load_so_libflimage(), "flps_init", 
11531              cty.POINTER(FLPS_CONTROL), [], 
11532              """)FLPS_CONTROL * flps_init() 
11533              """) 
11534      retval = _flps_init() 
11535      return retval 
11536   
11537   
11538 -def fl_object_ps_dump(pObject, fname): 
11539      """ fl_object_ps_dump(pObject, fname) -> num. 
11540      """ 
11541   
11542      _fl_object_ps_dump = cfuncproto( 
11543              load_so_libflimage(), "fl_object_ps_dump", 
11544              cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 
11545              """int fl_object_ps_dump(FL_OBJECT * ob, const char * fname) 
11546              """) 
11547      sfname = convert_to_string(fname) 
11548      keep_elem_refs(pObject, fname, sfname) 
11549      retval = _fl_object_ps_dump(pObject, sfname) 
11550      return retval 
11551   
11552   
11553   
11554  ########################## 
11555  # forms.h (formbrowser.h) 
11556  ########################## 
11557   
11558 -def fl_addto_formbrowser(pObject, pForm): 
11559      """ fl_addto_formbrowser(pObject, pForm) -> num. 
11560      """ 
11561   
11562      _fl_addto_formbrowser = cfuncproto( 
11563              load_so_libforms(), "fl_addto_formbrowser", 
11564              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 
11565              """int fl_addto_formbrowser(FL_OBJECT * ob, FL_FORM * form) 
11566              """) 
11567      keep_elem_refs(pObject, pForm) 
11568      retval = _fl_addto_formbrowser(pObject, pForm) 
11569      return retval 
11570   
11571   
11572 -def fl_delete_formbrowser_bynumber(pObject, num): 
11573      """ fl_delete_formbrowser_bynumber(pObject, num) -> pForm 
11574      """ 
11575   
11576      _fl_delete_formbrowser_bynumber = cfuncproto( 
11577              load_so_libforms(), "fl_delete_formbrowser_bynumber", 
11578              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 
11579              """FL_FORM * fl_delete_formbrowser_bynumber(FL_OBJECT * ob, 
11580                 int num) 
11581              """) 
11582      inum = convert_to_int(num) 
11583      keep_elem_refs(pObject, num, inum) 
11584      retval = _fl_delete_formbrowser_bynumber(pObject, inum) 
11585      return retval 
11586   
11587   
11588 -def fl_delete_formbrowser(pObject, pFormCandidate): 
11589      """ fl_delete_formbrowser(pObject, pFormCandidate) -> num. 
11590      """ 
11591   
11592      _fl_delete_formbrowser = cfuncproto( 
11593              load_so_libforms(), "fl_delete_formbrowser", 
11594              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 
11595              """int fl_delete_formbrowser(FL_OBJECT * ob, 
11596                 FL_FORM * candidate_form) 
11597              """) 
11598      keep_elem_refs(pObject, pFormCandidate) 
11599      retval = _fl_delete_formbrowser(pObject, pFormCandidate) 
11600      return retval 
11601   
11602   
11603 -def fl_replace_formbrowser(pObject, num, pForm): 
11604      """ fl_replace_formbrowser(pObject, num, pForm) 
11605      """ 
11606   
11607      _fl_replace_formbrowser = cfuncproto( 
11608              load_so_libforms(), "fl_replace_formbrowser", 
11609              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int, 
11610              cty.POINTER(FL_FORM)], 
11611              """FL_FORM * fl_replace_formbrowser(FL_OBJECT * ob, int num, 
11612                 FL_FORM * form) 
11613              """) 
11614      inum = convert_to_int(num) 
11615      keep_elem_refs(pObject, num, pForm, inum) 
11616      retval = _fl_replace_formbrowser(pObject, inum, pForm) 
11617      return retval 
11618   
11619   
11620 -def fl_insert_formbrowser(pObject, line, pFormNew): 
11621      """ fl_insert_formbrowser(pObject, line, pFormNew) -> num. 
11622      """ 
11623   
11624      _fl_insert_formbrowser = cfuncproto( 
11625              load_so_libforms(), "fl_insert_formbrowser", 
11626              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, \ 
11627              cty.POINTER(FL_FORM)], 
11628              """int fl_insert_formbrowser(FL_OBJECT * ob, int line, 
11629                 FL_FORM * new_form) 
11630              """) 
11631      iline = convert_to_int(line) 
11632      keep_elem_refs(pObject, line, iline, pFormNew) 
11633      retval = _fl_insert_formbrowser(pObject, iline, pFormNew) 
11634      return retval 
11635   
11636   
11637  #def fl_get_formbrowser_area(pObject, x, y, w, h)       *API change* 
11638 -def fl_get_formbrowser_area(pObject): 
11639      """ fl_get_formbrowser_area(pObject) -> num., x, y, w, h 
11640      """ 
11641   
11642      _fl_get_formbrowser_area = cfuncproto( 
11643              load_so_libforms(), "fl_get_formbrowser_area", 
11644              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
11645              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), \ 
11646              cty.POINTER(cty.c_int)], 
11647              """int fl_get_formbrowser_area(FL_OBJECT * ob, int * x, int * y, 
11648                 int * w, int * h) 
11649              """) 
11650      x, px = make_int_and_pointer() 
11651      y, py = make_int_and_pointer() 
11652      w, pw = make_int_and_pointer() 
11653      h, ph = make_int_and_pointer() 
11654      keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 
11655      retval = _fl_get_formbrowser_area(pObject, px, py, pw, ph) 
11656      return retval, x, y, w, h 
11657   
11658   
11659 -def fl_set_formbrowser_scroll(pObject, how): 
11660      """ fl_set_formbrowser_scroll(pObject, how) 
11661      """ 
11662   
11663      _fl_set_formbrowser_scroll = cfuncproto( 
11664              load_so_libforms(), "fl_set_formbrowser_scroll", 
11665              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11666              """void fl_set_formbrowser_scroll(FL_OBJECT * ob, int how) 
11667              """) 
11668      ihow = convert_to_int(how) 
11669      keep_elem_refs(pObject, how, ihow) 
11670      _fl_set_formbrowser_scroll(pObject, ihow) 
11671   
11672   
11673 -def fl_set_formbrowser_hscrollbar(pObject, how): 
11674      """ fl_set_formbrowser_hscrollbar(pObject, how) 
11675      """ 
11676   
11677      _fl_set_formbrowser_hscrollbar = cfuncproto( 
11678              load_so_libforms(), "fl_set_formbrowser_hscrollbar", 
11679              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11680              """void fl_set_formbrowser_hscrollbar(FL_OBJECT * ob, int how) 
11681              """) 
11682      ihow = convert_to_int(how) 
11683      keep_elem_refs(pObject, how, ihow) 
11684      _fl_set_formbrowser_hscrollbar(pObject, ihow) 
11685   
11686   
11687 -def fl_set_formbrowser_vscrollbar(pObject, how): 
11688      """ fl_set_formbrowser_vscrollbar(pObject, how) 
11689      """ 
11690   
11691      _fl_set_formbrowser_vscrollbar = cfuncproto( 
11692              load_so_libforms(), "fl_set_formbrowser_vscrollbar", 
11693              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11694              """void fl_set_formbrowser_vscrollbar(FL_OBJECT * ob, int how) 
11695              """) 
11696      ihow = convert_to_int(how) 
11697      keep_elem_refs(pObject, how, ihow) 
11698      _fl_set_formbrowser_vscrollbar(pObject, ihow) 
11699   
11700   
11701 -def fl_get_formbrowser_topform(pObject): 
11702      """ fl_get_formbrowser_topform(pObject) -> pForm 
11703      """ 
11704   
11705      _fl_get_formbrowser_topform = cfuncproto( 
11706              load_so_libforms(), "fl_get_formbrowser_topform", 
11707              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT)], 
11708              """FL_FORM * fl_get_formbrowser_topform(FL_OBJECT * ob) 
11709              """) 
11710      keep_elem_refs(pObject) 
11711      retval = _fl_get_formbrowser_topform(pObject) 
11712      return retval 
11713   
11714   
11715 -def fl_set_formbrowser_topform(pObject, pForm): 
11716      """ fl_set_formbrowser_topform(pObject, pForm) -> num. 
11717      """ 
11718   
11719      _fl_set_formbrowser_topform = cfuncproto( 
11720              load_so_libforms(), "fl_set_formbrowser_topform", 
11721              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 
11722              """int fl_set_formbrowser_topform(FL_OBJECT * ob, FL_FORM * form) 
11723              """) 
11724      keep_elem_refs(pObject, pForm) 
11725      retval = _fl_set_formbrowser_topform(pObject, pForm) 
11726      return retval 
11727   
11728   
11729 -def fl_set_formbrowser_topform_bynumber(pObject, n): 
11730      """ fl_set_formbrowser_topform_bynumber(pObject, n) -> pForm 
11731      """ 
11732   
11733      _fl_set_formbrowser_topform_bynumber = cfuncproto( 
11734              load_so_libforms(), "fl_set_formbrowser_topform_bynumber", 
11735              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 
11736              """FL_FORM * fl_set_formbrowser_topform_bynumber( \ 
11737                 FL_OBJECT * ob, int n) 
11738              """) 
11739      inum = convert_to_int(n) 
11740      keep_elem_refs(pObject, n, inum) 
11741      retval = _fl_set_formbrowser_topform_bynumber(pObject, inum) 
11742      return retval 
11743   
11744   
11745 -def fl_set_formbrowser_xoffset(pObject, offset): 
11746      """ 
11747          fl_set_formbrowser_xoffset(pObject, offset) -> num. 
11748   
11749          Scrolls within a formbrowser in horizontal direction. 
11750   
11751          @param pObject : pointer to formbrowser object 
11752          @param offset : positive number, measuring in pixels the offset 
11753             from the the natural position from the left 
11754      """ 
11755   
11756      _fl_set_formbrowser_xoffset = cfuncproto( 
11757              load_so_libforms(), "fl_set_formbrowser_xoffset", 
11758              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
11759              """int fl_set_formbrowser_xoffset(FL_OBJECT * ob, int offset) 
11760              """) 
11761      ioffset = convert_to_int(offset) 
11762      keep_elem_refs(pObject, offset, ioffset) 
11763      retval = _fl_set_formbrowser_xoffset(pObject, ioffset) 
11764      return retval 
11765   
11766   
11767 -def fl_set_formbrowser_yoffset(pObject, offset): 
11768      """ 
11769          fl_set_formbrowser_yoffset(pObject, offset) -> num. 
11770   
11771          Scrolls within a formbrowser in vertical direction. 
11772   
11773          @param pObject : pointer to formbrowser object 
11774          @param offset : positive number, measuring in pixels the offset 
11775             from the the natural position from the top 
11776      """ 
11777   
11778      _fl_set_formbrowser_yoffset = cfuncproto( 
11779              load_so_libforms(), "fl_set_formbrowser_yoffset", 
11780              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
11781              """int fl_set_formbrowser_yoffset(FL_OBJECT * ob, int offset) 
11782              """) 
11783      ioffset = convert_to_int(offset) 
11784      keep_elem_refs(pObject, offset, ioffset) 
11785      retval = _fl_set_formbrowser_yoffset(pObject, ioffset) 
11786      return retval 
11787   
11788   
11789 -def fl_get_formbrowser_xoffset(pObject): 
11790      """ 
11791          fl_get_formbrowser_xoffset(pObject) -> num. 
11792   
11793          Returns the current horizontal offset from left in pixel of a 
11794          formbrowser. 
11795   
11796          @param pObject : pointer to formbrowser object 
11797      """ 
11798   
11799      _fl_get_formbrowser_xoffset = cfuncproto( 
11800              load_so_libforms(), "fl_get_formbrowser_xoffset", 
11801              cty.c_int, [cty.POINTER(FL_OBJECT)], 
11802              """int fl_get_formbrowser_xoffset(FL_OBJECT * ob) 
11803              """) 
11804      keep_elem_refs(pObject) 
11805      retval = _fl_get_formbrowser_xoffset(pObject) 
11806      return retval 
11807   
11808   
11809 -def fl_get_formbrowser_yoffset(pObject): 
11810      """ 
11811          fl_get_formbrowser_yoffset(pObject) -> num. 
11812   
11813          Returns the current vertical offset from top in pixel of a 
11814          formbrowser. 
11815   
11816          @param pObject : pointer to formbrowser object 
11817      """ 
11818   
11819      _fl_get_formbrowser_yoffset = cfuncproto( 
11820              load_so_libforms(), "fl_get_formbrowser_yoffset", 
11821              cty.c_int, [cty.POINTER(FL_OBJECT)], 
11822              """int fl_get_formbrowser_yoffset(FL_OBJECT * ob) 
11823              """) 
11824      keep_elem_refs(pObject) 
11825      retval = _fl_get_formbrowser_yoffset(pObject) 
11826      return retval 
11827   
11828   
11829 -def fl_find_formbrowser_form_number(pObject, pFormCandidate): 
11830      """ fl_find_formbrowser_form_number(pObject, pFormCandidate) -> num. 
11831      """ 
11832   
11833      _fl_find_formbrowser_form_number = cfuncproto( 
11834              load_so_libforms(), "fl_find_formbrowser_form_number", 
11835              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 
11836              """int fl_find_formbrowser_form_number(FL_OBJECT * ob, 
11837                 FL_FORM * candidate_form) 
11838              """) 
11839      keep_elem_refs(pObject, pFormCandidate) 
11840      retval = _fl_find_formbrowser_form_number(pObject, pFormCandidate) 
11841      return retval 
11842   
11843   
11844 -def fl_add_formbrowser(frmbrwstype, x, y, w, h, label): 
11845      """ fl_add_formbrowser(frmbrwstype, x, y, w, h, label) -> pObject 
11846      """ 
11847   
11848      _fl_add_formbrowser = cfuncproto( 
11849              load_so_libforms(), "fl_add_formbrowser", 
11850              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, 
11851              FL_Coord, FL_Coord, STRING], 
11852              """FL_OBJECT * fl_add_formbrowser(int type, FL_Coord x, 
11853                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
11854              """) 
11855      check_admitted_listvalues(frmbrwstype, FORMBRWSTYPE_list) 
11856      ifrmbrwstype = convert_to_int(frmbrwstype) 
11857      ix = convert_to_FL_Coord(x) 
11858      iy = convert_to_FL_Coord(y) 
11859      iw = convert_to_FL_Coord(w) 
11860      ih = convert_to_FL_Coord(h) 
11861      slabel = convert_to_string(label) 
11862      keep_elem_refs(frmbrwstype, x, y, w, h, label, ifrmbrwstype, ix, iy, 
11863                     iw, ih, slabel) 
11864      retval = _fl_add_formbrowser(ifrmbrwstype, ix, iy, iw, ih, slabel) 
11865      return retval 
11866   
11867   
11868 -def fl_create_formbrowser(frmbrwstype, x, y, w, h, label): 
11869      """ fl_create_formbrowser(frmbrwstype, x, y, w, h, label) -> pObject 
11870      """ 
11871   
11872      _fl_create_formbrowser = cfuncproto( 
11873              load_so_libforms(), "fl_create_formbrowser", 
11874              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, 
11875              FL_Coord, FL_Coord, STRING], 
11876              """FL_OBJECT * fl_create_formbrowser(int type, FL_Coord x, 
11877                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
11878              """) 
11879      check_admitted_listvalues(frmbrwstype, FORMBRWSTYPE_list) 
11880      ifrmbrwstype = convert_to_int(frmbrwstype) 
11881      ix = convert_to_FL_Coord(x) 
11882      iy = convert_to_FL_Coord(y) 
11883      iw = convert_to_FL_Coord(w) 
11884      ih = convert_to_FL_Coord(h) 
11885      slabel = convert_to_string(label) 
11886      keep_elem_refs(frmbrwstype, x, y, w, h, label, ifrmbrwstype, ix, iy, 
11887                     iw, ih, slabel) 
11888      retval = _fl_create_formbrowser(ifrmbrwstype, ix, iy, iw, ih, slabel) 
11889      return retval 
11890   
11891   
11892 -def fl_get_formbrowser_numforms(pObject): 
11893      """ fl_get_formbrowser_numforms(pObject) -> forms num. 
11894      """ 
11895   
11896      _fl_get_formbrowser_numforms = cfuncproto( 
11897              load_so_libforms(), "fl_get_formbrowser_numforms", 
11898              cty.c_int, [cty.POINTER(FL_OBJECT)], 
11899              """int fl_get_formbrowser_numforms(FL_OBJECT * ob) 
11900              """) 
11901      keep_elem_refs(pObject) 
11902      retval = _fl_get_formbrowser_numforms(pObject) 
11903      return retval 
11904   
11905   
11906 -def fl_get_formbrowser_form(pObject, n): 
11907      """ fl_get_formbrowser_form(pObject, n) -> pForm 
11908      """ 
11909   
11910      _fl_get_formbrowser_form = cfuncproto( 
11911              load_so_libforms(), "fl_get_formbrowser_form", 
11912              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 
11913              """FL_FORM * fl_get_formbrowser_form(FL_OBJECT * ob, int n) 
11914              """) 
11915      inum = convert_to_int(n) 
11916      keep_elem_refs(pObject, n, inum) 
11917      retval = _fl_get_formbrowser_form(pObject, inum) 
11918      return retval 
11919   
11920   
11921   
11922  #################### 
11923  # forms.h (frame.h) 
11924  #################### 
11925   
11926 -def fl_create_frame(frametype, x, y, w, h, label): 
11927      """ fl_create_frame(frametype, x, y, w, h, label) -> pObject 
11928      """ 
11929   
11930      _fl_create_frame = cfuncproto( 
11931              load_so_libforms(), "fl_create_frame", 
11932              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
11933              FL_Coord, STRING], 
11934              """FL_OBJECT * fl_create_frame(int type, FL_Coord x, FL_Coord y, 
11935                 FL_Coord w, FL_Coord h, const char * label) 
11936              """) 
11937      check_admitted_listvalues(frametype, FRAMETYPE_list) 
11938      iframetype = convert_to_int(frametype) 
11939      ix = convert_to_FL_Coord(x) 
11940      iy = convert_to_FL_Coord(y) 
11941      iw = convert_to_FL_Coord(w) 
11942      ih = convert_to_FL_Coord(h) 
11943      slabel = convert_to_string(label) 
11944      keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 
11945                     iw, ih, slabel) 
11946      retval = _fl_create_frame(iframetype, ix, iy, iw, ih, slabel) 
11947      return retval 
11948   
11949   
11950 -def fl_add_frame(frametype, x, y, w, h, label): 
11951      """ fl_add_frame(frametype, x, y, w, h, label) -> pObject 
11952      """ 
11953   
11954      _fl_add_frame = cfuncproto( 
11955              load_so_libforms(), "fl_add_frame", 
11956              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
11957              FL_Coord, STRING], 
11958              """FL_OBJECT * fl_add_frame(int type, FL_Coord x, FL_Coord y, 
11959                 FL_Coord w, FL_Coord h, const char * label) 
11960              """) 
11961      check_admitted_listvalues(frametype, FRAMETYPE_list) 
11962      iframetype = convert_to_int(frametype) 
11963      ix = convert_to_FL_Coord(x) 
11964      iy = convert_to_FL_Coord(y) 
11965      iw = convert_to_FL_Coord(w) 
11966      ih = convert_to_FL_Coord(h) 
11967      slabel = convert_to_string(label) 
11968      keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 
11969                     iw, ih, slabel) 
11970      retval = _fl_add_frame(iframetype, ix, iy, iw, ih, slabel) 
11971      return retval 
11972   
11973   
11974  # labeld frame 
11975   
11976 -def fl_create_labelframe(frametype, x, y, w, h, label): 
11977      """ fl_create_labelframe(frametype, x, y, w, h, label) -> pObject 
11978      """ 
11979   
11980      _fl_create_labelframe = cfuncproto( 
11981              load_so_libforms(), "fl_create_labelframe", 
11982              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
11983              FL_Coord, STRING], 
11984              """FL_OBJECT * fl_create_labelframe(int type, FL_Coord x, 
11985                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
11986              """) 
11987      iframetype = convert_to_int(frametype) 
11988      ix = convert_to_FL_Coord(x) 
11989      iy = convert_to_FL_Coord(y) 
11990      iw = convert_to_FL_Coord(w) 
11991      ih = convert_to_FL_Coord(h) 
11992      slabel = convert_to_string(label) 
11993      keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 
11994                     iw, ih, slabel) 
11995      retval = _fl_create_labelframe(iframetype, ix, iy, iw, ih, slabel) 
11996      return retval 
11997   
11998   
11999 -def fl_add_labelframe(frametype, x, y, w, h, label): 
12000      """ fl_add_labelframe(frametype, x, y, w, h, label) -> pObject 
12001      """ 
12002   
12003      _fl_add_labelframe = cfuncproto( 
12004              load_so_libforms(), "fl_add_labelframe", 
12005              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
12006              FL_Coord, STRING], 
12007              """FL_OBJECT * fl_add_labelframe(int type, FL_Coord x, FL_Coord y, 
12008                 FL_Coord w, FL_Coord h, const char * label) 
12009              """) 
12010      iframetype = convert_to_int(frametype) 
12011      ix = convert_to_FL_Coord(x) 
12012      iy = convert_to_FL_Coord(y) 
12013      iw = convert_to_FL_Coord(w) 
12014      ih = convert_to_FL_Coord(h) 
12015      slabel = convert_to_string(label) 
12016      keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 
12017                     iw, ih, slabel) 
12018      retval = _fl_add_labelframe(iframetype, ix, iy, iw, ih, slabel) 
12019      return retval 
12020   
12021   
12022   
12023  ##################### 
12024  # forms.h (free.h) 
12025  # Object Class: Free 
12026  ##################### 
12027   
12028 -def fl_create_free(freetype, x, y, w, h, label, py_HandlePtr): 
12029      """ fl_create_free(freetype, x, y, w, h, label, py_HandlePtr) -> pObject 
12030      """ 
12031   
12032      _fl_create_free = cfuncproto( 
12033              load_so_libforms(), "fl_create_free", 
12034              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
12035              FL_Coord, STRING, FL_HANDLEPTR], 
12036              """FL_OBJECT * fl_create_free(int type, FL_Coord x, FL_Coord y, 
12037                 FL_Coord w, FL_Coord h, const char * label, 
12038                 FL_HANDLEPTR handle) 
12039              """) 
12040      check_admitted_listvalues(freetype, FREETYPE_list) 
12041      ifreetype = convert_to_int(freetype) 
12042      ix = convert_to_FL_Coord(x) 
12043      iy = convert_to_FL_Coord(y) 
12044      iw = convert_to_FL_Coord(w) 
12045      ih = convert_to_FL_Coord(h) 
12046      slabel = convert_to_string(label) 
12047      c_HandlePtr = FL_HANDLEPTR(py_HandlePtr) 
12048      keep_cfunc_refs(c_HandlePtr, py_HandlePtr) 
12049      keep_elem_refs(freetype, x, y, w, h, label, ifreetype, ix, iy, iw, ih, 
12050                     slabel) 
12051      retval = _fl_create_free(ifreetype, ix, iy, iw, ih, slabel, c_HandlePtr) 
12052      return retval 
12053   
12054   
12055 -def fl_add_free(freetype, x, y, w, h, label, py_HandlePtr): 
12056      """ fl_add_free(freetype, x, y, w, h, label, py_HandlePtr) -> pObject 
12057      """ 
12058   
12059      _fl_add_free = cfuncproto( 
12060              load_so_libforms(), "fl_add_free", 
12061              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
12062              FL_Coord, STRING, FL_HANDLEPTR], 
12063              """FL_OBJECT * fl_add_free(int type, FL_Coord x, FL_Coord y, 
12064                 FL_Coord w, FL_Coord h, const char * label, 
12065                 FL_HANDLEPTR handle) 
12066              """) 
12067      check_admitted_listvalues(freetype, FREETYPE_list) 
12068      ifreetype = convert_to_int(freetype) 
12069      ix = convert_to_FL_Coord(x) 
12070      iy = convert_to_FL_Coord(y) 
12071      iw = convert_to_FL_Coord(w) 
12072      ih = convert_to_FL_Coord(h) 
12073      slabel = convert_to_string(label) 
12074      c_HandlePtr = FL_HANDLEPTR(py_HandlePtr) 
12075      keep_cfunc_refs(c_HandlePtr, py_HandlePtr) 
12076      keep_elem_refs(freetype, x, y, w, h, label, ifreetype, ix, iy, iw, ih, 
12077                     slabel) 
12078      retval = _fl_add_free(ifreetype, ix, iy, iw, ih, slabel, c_HandlePtr) 
12079      return retval 
12080   
12081   
12082   
12083  ###################### 
12084  # forms.h (goodies.h) 
12085  ###################### 
12086   
12087  # Resources and misc. goodie routines 
12088   
12089 -def fl_set_goodies_font(style, size): 
12090      """ fl_set_goodies_font(style, size) 
12091      """ 
12092   
12093      _fl_set_goodies_font = cfuncproto( 
12094              load_so_libforms(), "fl_set_goodies_font", 
12095              None, [cty.c_int, cty.c_int], 
12096              """void fl_set_goodies_font(int style, int size) 
12097              """) 
12098      istyle = convert_to_int(style) 
12099      isize = convert_to_int(size) 
12100      keep_elem_refs(style, size, istyle, isize) 
12101      _fl_set_goodies_font(istyle, isize) 
12102   
12103   
12104  # messages and questions 
12105   
12106 -def fl_show_message(msgtxt1, msgtxt2, msgtxt3): 
12107      """ 
12108          fl_show_message(msgtxt1, msgtxt2, msgtxt3) 
12109   
12110          Shows a message. 
12111   
12112          @param msgtxt1 : first message to show 
12113          @param msgtxt2 : second message to show 
12114          @param msgtxt3 : third message to show 
12115      """ 
12116   
12117      _fl_show_message = cfuncproto( 
12118              load_so_libforms(), "fl_show_message", 
12119              None, [STRING, STRING, STRING], 
12120              """void fl_show_message(const char * p1, const char * p2, 
12121                 const char * p3) 
12122              """) 
12123      smsgtxt1 = convert_to_string(msgtxt1) 
12124      smsgtxt2 = convert_to_string(msgtxt2) 
12125      smsgtxt3 = convert_to_string(msgtxt3) 
12126      keep_elem_refs(msgtxt1, msgtxt2, msgtxt3, smsgtxt1, smsgtxt2, smsgtxt3) 
12127      _fl_show_message(smsgtxt1, smsgtxt2, smsgtxt3) 
12128   
12129   
12130 -def fl_show_messages(p1): 
12131      """ fl_show_messages(p1) 
12132      """ 
12133   
12134      _fl_show_messages = cfuncproto( 
12135              load_so_libforms(), "fl_show_messages", 
12136              None, [STRING], 
12137              """void fl_show_messages(const char * p1) 
12138              """) 
12139      sp1 = convert_to_string(p1) 
12140      keep_elem_refs(p1, sp1) 
12141      _fl_show_messages(sp1) 
12142   
12143   
12144 -def fl_show_msg(fmttxt): 
12145      """ 
12146          fl_show_msg(fmttxt) 
12147   
12148          Shows a text message. 
12149   
12150          @param fmttxt : text message to show (with format parameters, e.g. 
12151             %s, %d, %f etc..) 
12152      """ 
12153   
12154      _fl_show_msg = cfuncproto( 
12155              load_so_libforms(), "fl_show_msg", 
12156              None, [STRING], 
12157              """void fl_show_msg(const char * p1) 
12158              """) 
12159      sfmttxt = convert_to_string(fmttxt) 
12160      keep_elem_refs(fmttxt, sfmttxt) 
12161      _fl_show_msg(sfmttxt) 
12162   
12163   
12164 -def fl_hide_message(): 
12165      """ 
12166          fl_hide_message() 
12167   
12168          Hides a text message already shown. 
12169      """ 
12170   
12171      _fl_hide_message = cfuncproto( 
12172              load_so_libforms(), "fl_hide_message", 
12173              None, [], 
12174              """void fl_hide_message() 
12175              """) 
12176      _fl_hide_message() 
12177   
12178   
12179  fl_hide_msg = fl_hide_message 
12180  fl_hide_messages = fl_hide_message 
12181   
12182   
12183 -def fl_show_question(questmsg, p2): 
12184      """ 
12185          fl_show_question(questmsg, p2) -> num. 
12186   
12187          Shows a question message. 
12188   
12189          @param questmsg : text of question message to show 
12190          @param p2 : ? 
12191      """ 
12192   
12193      _fl_show_question = cfuncproto( 
12194              load_so_libforms(), "fl_show_question", 
12195              cty.c_int, [STRING, cty.c_int], 
12196              """int fl_show_question(const char * p1, int p2) 
12197              """) 
12198      squestmsg = convert_to_string(questmsg) 
12199      ip2 = convert_to_int(p2) 
12200      keep_elem_refs(questmsg, p2, squestmsg, ip2) 
12201      retval = _fl_show_question(squestmsg, ip2) 
12202      return retval 
12203   
12204   
12205 -def fl_hide_question(): 
12206      """ 
12207          fl_hide_question() 
12208   
12209          Hides a question message already shown. 
12210      """ 
12211   
12212      _fl_hide_question = cfuncproto( 
12213              load_so_libforms(), "fl_hide_question", 
12214              None, [], 
12215              """void fl_hide_question() 
12216              """) 
12217      _fl_hide_question() 
12218   
12219   
12220 -def fl_show_alert(p1, p2, p3, p4): 
12221      """ fl_show_alert(p1, p2, p3, p4) 
12222      """ 
12223   
12224      _fl_show_alert = cfuncproto( 
12225              load_so_libforms(), "fl_show_alert", 
12226              None, [STRING, STRING, STRING, cty.c_int], 
12227              """void fl_show_alert(const char * p1, const char * p2, 
12228                 const char * p3, int p4) 
12229              """) 
12230      sp1 = convert_to_string(p1) 
12231      sp2 = convert_to_string(p2) 
12232      sp3 = convert_to_string(p3) 
12233      ip4 = convert_to_int(p4) 
12234      keep_elem_refs(p1, p2, p3, p4, sp1, sp2, sp3, ip4) 
12235      _fl_show_alert(sp1, sp2, sp3, ip4) 
12236   
12237   
12238 -def fl_show_alert2(c, fmt): 
12239      """ fl_show_alert2(c, fmt) 
12240      """ 
12241   
12242      _fl_show_alert2 = cfuncproto( 
12243              load_so_libforms(), "fl_show_alert2", 
12244              None, [cty.c_int, STRING], 
12245              """void fl_show_alert2(int c, const char * fmt) 
12246              """) 
12247      ic = convert_to_int(c) 
12248      sfmt = convert_to_string(fmt) 
12249      keep_elem_refs(c, fmt, ic, sfmt) 
12250      _fl_show_alert2(ic, sfmt) 
12251   
12252   
12253 -def fl_hide_alert(): 
12254      """ fl_hide_alert() 
12255      """ 
12256   
12257      _fl_hide_alert = cfuncproto( 
12258              load_so_libforms(), "fl_hide_alert", 
12259              None, [], 
12260              """void fl_hide_alert() 
12261              """) 
12262      _fl_hide_alert() 
12263   
12264   
12265 -def fl_show_input(p1, p2): 
12266      """ fl_show_input(p1, p2) -> input string 
12267      """ 
12268   
12269      _fl_show_input = cfuncproto( 
12270              load_so_libforms(), "fl_show_input", 
12271              STRING, [STRING, STRING], 
12272              """const char * fl_show_input(const char * p1, const char * p2) 
12273              """) 
12274      sp1 = convert_to_string(p1) 
12275      sp2 = convert_to_string(p2) 
12276      keep_elem_refs(p1, p2, sp1, sp2) 
12277      retval = _fl_show_input(sp1, sp2) 
12278      return retval 
12279   
12280   
12281 -def fl_hide_input(): 
12282      """ fl_hide_input() 
12283      """ 
12284   
12285      _fl_hide_input = cfuncproto( 
12286              load_so_libforms(), "fl_hide_input", 
12287              None, [], 
12288              """void fl_hide_input() 
12289              """) 
12290      _fl_hide_input() 
12291   
12292   
12293 -def fl_show_simple_input(msgtxt, defstr): 
12294      """ 
12295          fl_show_simple_input(msgtxt, defstr) -> input string 
12296   
12297          Asks the user for textual input. 
12298   
12299          @param msgtxt : text message 
12300          @param defstr : default user answer in input 
12301      """ 
12302   
12303      _fl_show_simple_input = cfuncproto( 
12304              load_so_libforms(), "fl_show_simple_input", 
12305              STRING, [STRING, STRING], 
12306              """const char * fl_show_simple_input(const char * p1, 
12307                 const char * p2) 
12308              """) 
12309      smsgtxt = convert_to_string(msgtxt) 
12310      sdefstr = convert_to_string(defstr) 
12311      keep_elem_refs(msgtxt, defstr, smsgtxt, sdefstr) 
12312      retval = _fl_show_simple_input(smsgtxt, sdefstr) 
12313      return retval 
12314   
12315   
12316 -def fl_show_colormap(oldcolr): 
12317      """ fl_show_colormap(oldcolr) -> colormap num. 
12318          Shows a colormap color selector from which the user can select a color. 
12319          <oldcolr> : color num. 
12320      """ 
12321   
12322      _fl_show_colormap = cfuncproto( 
12323              load_so_libforms(), "fl_show_colormap", 
12324              cty.c_int, [cty.c_int], 
12325              """int fl_show_colormap(int p1) 
12326              """) 
12327      ioldcolr = convert_to_int(oldcolr) 
12328      keep_elem_refs(oldcolr, ioldcolr) 
12329      retval = _fl_show_colormap(ioldcolr) 
12330      return retval 
12331   
12332   
12333  # choices 
12334   
12335 -def fl_show_choices(p1, p2, p3, p4, p5, p6): 
12336      """ fl_show_choices(p1, p2, p3, p4, p5, p6) -> num. 
12337      """ 
12338   
12339      _fl_show_choices = cfuncproto( 
12340              load_so_libforms(), "fl_show_choices", 
12341              cty.c_int, [STRING, cty.c_int, STRING, STRING, STRING, 
12342              cty.c_int], 
12343              """int fl_show_choices(const char * p1, int p2, 
12344                 const char * p3, const char * p4, const char * p5, int p6) 
12345              """) 
12346      sp1 = convert_to_string(p1) 
12347      ip2 = convert_to_int(p2) 
12348      sp3 = convert_to_string(p3) 
12349      sp4 = convert_to_string(p4) 
12350      sp5 = convert_to_string(p5) 
12351      ip6 = convert_to_int(p6) 
12352      keep_elem_refs(p1, p2, p3, p4, p5, p6, sp1, ip2, sp3, sp4, sp5, ip6) 
12353      retval = _fl_show_choices(sp1, ip2, sp3, sp4, sp5, ip6) 
12354      return retval 
12355   
12356   
12357 -def fl_show_choice(p1, p2, p3, p4, p5, p6, p7, p8): 
12358      """ fl_show_choice(p1, p2, p3, p4, p5, p6, p7, p8) -> num. 
12359      """ 
12360   
12361      _fl_show_choice = cfuncproto( 
12362              load_so_libforms(), "fl_show_choice", 
12363              cty.c_int, [STRING, STRING, STRING, cty.c_int, STRING, STRING, 
12364              STRING, cty.c_int], 
12365              """int fl_show_choice(const char * p1, const char * p2, 
12366                 const char * p3, int p4, const char * p5, const char * p6, 
12367                 const char * p7, int p8) 
12368              """) 
12369      sp1 = convert_to_string(p1) 
12370      sp2 = convert_to_string(p2) 
12371      sp3 = convert_to_string(p3) 
12372      ip4 = convert_to_int(p4) 
12373      sp5 = convert_to_string(p5) 
12374      sp6 = convert_to_string(p6) 
12375      sp7 = convert_to_string(p7) 
12376      ip8 = convert_to_int(p8) 
12377      keep_elem_refs(sp1, sp2, sp3, ip4, sp5, sp6, sp7, ip8) 
12378      retval = _fl_show_choice(sp1, sp2, sp3, ip4, sp5, sp6, sp7, ip8) 
12379      return retval 
12380   
12381   
12382 -def fl_hide_choice(): 
12383      """ fl_hide_choice() 
12384      """ 
12385   
12386      _fl_hide_choice = cfuncproto( 
12387              load_so_libforms(), "fl_hide_choice", 
12388              None, [], 
12389              """void fl_hide_choice() 
12390              """) 
12391      _fl_hide_choice() 
12392   
12393   
12394 -def fl_set_choices_shortcut(p1, p2, p3): 
12395      """ fl_set_choices_shortcut(p1, p2, p3) 
12396      """ 
12397   
12398      _fl_set_choices_shortcut = cfuncproto( 
12399              load_so_libforms(), "fl_set_choices_shortcut", 
12400              None, [STRING, STRING, STRING], 
12401              """void fl_set_choices_shortcut(const char * p1, const char * p2, 
12402                 const char * p3) 
12403              """) 
12404      sp1 = convert_to_string(p1) 
12405      sp2 = convert_to_string(p2) 
12406      sp3 = convert_to_string(p3) 
12407      keep_elem_refs(p1, p2, p3, sp1, sp2, sp3) 
12408      _fl_set_choices_shortcut(sp1, sp2, sp3) 
12409   
12410   
12411  fl_set_choice_shortcut = fl_set_choices_shortcut 
12412   
12413   
12414  # one liner 
12415   
12416 -def fl_show_oneliner(p1, p2, p3): 
12417      """ fl_show_oneliner(p1, p2, p3) 
12418      """ 
12419   
12420      _fl_show_oneliner = cfuncproto( 
12421              load_so_libforms(), "fl_show_oneliner", 
12422              None, [STRING, FL_Coord, FL_Coord], 
12423              """void fl_show_oneliner(const char * p1, FL_Coord p2, 
12424                 FL_Coord p3) 
12425              """) 
12426      sp1 = convert_to_string(p1) 
12427      ip2 = convert_to_FL_Coord(p2) 
12428      ip3 = convert_to_FL_Coord(p3) 
12429      keep_elem_refs(p1, p2, p3, sp1, ip2, ip3) 
12430      _fl_show_oneliner(sp1, ip2, ip3) 
12431   
12432   
12433 -def fl_hide_oneliner(): 
12434      """ fl_hide_oneliner() 
12435      """ 
12436   
12437      _fl_hide_oneliner = cfuncproto( 
12438              load_so_libforms(), "fl_hide_oneliner", 
12439              None, [], 
12440              """void fl_hide_oneliner() 
12441              """) 
12442      _fl_hide_oneliner() 
12443   
12444   
12445 -def fl_set_oneliner_font(p1, p2): 
12446      """ fl_set_oneliner_font(p1, p2) 
12447      """ 
12448   
12449      _fl_set_oneliner_font = cfuncproto( 
12450              load_so_libforms(), "fl_set_oneliner_font", 
12451              None, [cty.c_int, cty.c_int], 
12452              """void fl_set_oneliner_font(int p1, int p2) 
12453              """) 
12454      ip1 = convert_to_int(p1) 
12455      ip2 = convert_to_int(p2) 
12456      keep_elem_refs(p1, p2, ip1, ip2) 
12457      _fl_set_oneliner_font(ip1, ip2) 
12458   
12459   
12460 -def fl_set_oneliner_color(p1, p2): 
12461      """ fl_set_oneliner_color(p1, p2) 
12462      """ 
12463   
12464      _fl_set_oneliner_color = cfuncproto( 
12465              load_so_libforms(), "fl_set_oneliner_color", 
12466              None, [FL_COLOR, FL_COLOR], 
12467              """void fl_set_oneliner_color(FL_COLOR p1, FL_COLOR p2) 
12468              """) 
12469      ulp1 = convert_to_FL_COLOR(p1) 
12470      ulp2 = convert_to_FL_COLOR(p2) 
12471      keep_elem_refs(p1, p2, ulp1, ulp2) 
12472      _fl_set_oneliner_color(ulp1, ulp2) 
12473   
12474   
12475 -def fl_set_tooltip_font(p1, p2): 
12476      """ fl_set_tooltip_font(p1, p2) 
12477      """ 
12478   
12479      _fl_set_tooltip_font = cfuncproto( 
12480              load_so_libforms(), "fl_set_tooltip_font", 
12481              None, [cty.c_int, cty.c_int], 
12482              """void fl_set_tooltip_font(int p1, int p2) 
12483              """) 
12484      ip1 = convert_to_int(p1) 
12485      ip2 = convert_to_int(p2) 
12486      keep_elem_refs(p1, p2, ip1, ip2) 
12487      _fl_set_tooltip_font(ip1, ip2) 
12488   
12489   
12490 -def fl_set_tooltip_color(p1, p2): 
12491      """ fl_set_tooltip_color(p1, p2) 
12492      """ 
12493   
12494      _fl_set_tooltip_color = cfuncproto( 
12495              load_so_libforms(), "fl_set_tooltip_color", 
12496              None, [FL_COLOR, FL_COLOR], 
12497              """void fl_set_tooltip_color(FL_COLOR p1, FL_COLOR p2) 
12498              """) 
12499      ulp1 = convert_to_FL_COLOR(p1) 
12500      ulp2 = convert_to_FL_COLOR(p2) 
12501      keep_elem_refs(p1, p2, ulp1, ulp2) 
12502      _fl_set_tooltip_color(ulp1, ulp2) 
12503   
12504   
12505 -def fl_set_tooltip_boxtype(p1): 
12506      """ fl_set_tooltip_boxtype(p1) 
12507      """ 
12508   
12509      _fl_set_tooltip_boxtype = cfuncproto( 
12510              load_so_libforms(), "fl_set_tooltip_boxtype", 
12511              None, [cty.c_int], 
12512              """void fl_set_tooltip_boxtype(int p1) 
12513              """) 
12514      ip1 = convert_to_int(p1) 
12515      keep_elem_refs(p1, ip1) 
12516      _fl_set_tooltip_boxtype(ip1) 
12517   
12518   
12519 -def fl_set_tooltip_lalign(p1): 
12520      """ fl_set_tooltip_lalign(p1) 
12521      """ 
12522   
12523      _fl_set_tooltip_lalign = cfuncproto( 
12524              load_so_libforms(), "fl_set_tooltip_lalign", 
12525              None, [cty.c_int], 
12526              """void fl_set_tooltip_lalign(int p1) 
12527              """) 
12528      ip1 = convert_to_int(p1) 
12529      keep_elem_refs(p1, ip1) 
12530      _fl_set_tooltip_lalign(ip1) 
12531   
12532   
12533 -def fl_exe_command(p1, p2): 
12534      """ fl_exe_command(p1, p2) -> num. 
12535      """ 
12536   
12537      _fl_exe_command = cfuncproto( 
12538              load_so_libforms(), "fl_exe_command", 
12539              cty.c_long, [STRING, cty.c_int], 
12540              """long int fl_exe_command(const char * p1, int p2) 
12541              """) 
12542      sp1 = convert_to_string(p1) 
12543      ip2 = convert_to_int(p2) 
12544      keep_elem_refs(p1, sp1, p2, ip2) 
12545      retval = _fl_exe_command(sp1, ip2) 
12546      return retval 
12547   
12548   
12549 -def fl_end_command(p1): 
12550      """ fl_end_command(p1) -> num. 
12551      """ 
12552   
12553      _fl_end_command = cfuncproto( 
12554              load_so_libforms(), "fl_end_command", 
12555              cty.c_int, [cty.c_long], 
12556              """int fl_end_command(long int p1) 
12557              """) 
12558      lp1 = convert_to_long(p1) 
12559      keep_elem_refs(p1, lp1) 
12560      retval = _fl_end_command(lp1) 
12561      return retval 
12562   
12563   
12564 -def fl_check_command(p1): 
12565      """ fl_check_command(p1) -> num. 
12566      """ 
12567   
12568      _fl_check_command = cfuncproto( 
12569              load_so_libforms(), "fl_check_command", 
12570              cty.c_int, [cty.c_long], 
12571              """int fl_check_command(long int p1) 
12572              """) 
12573      lp1 = convert_to_long(p1) 
12574      keep_elem_refs(p1, lp1) 
12575      retval = _fl_check_command(lp1) 
12576      return retval 
12577   
12578   
12579 -def fl_popen(p1, p2): 
12580      """ fl_popen(p1, p2) -> FILE ptr. 
12581      """ 
12582   
12583      _fl_popen = cfuncproto( 
12584              load_so_libforms(), "fl_popen", 
12585              cty.POINTER(FILE), [STRING, STRING], 
12586              """FILE * fl_popen(const char * p1, const char * p2) 
12587              """) 
12588      sp1 = convert_to_string(p1) 
12589      sp2 = convert_to_string(p2) 
12590      keep_elem_refs(p1, p2, sp1, sp2) 
12591      retval = _fl_popen(sp1, sp2) 
12592      return retval 
12593   
12594   
12595 -def fl_pclose(p1): 
12596      """ fl_pclose(p1) -> num. 
12597      """ 
12598   
12599      _fl_pclose = cfuncproto( 
12600              load_so_libforms(), "fl_pclose", 
12601              cty.c_int, [cty.POINTER(FILE)], 
12602              """int fl_pclose(FILE * p1) 
12603              """) 
12604      keep_elem_refs(p1) 
12605      retval = _fl_pclose(p1) 
12606      return retval 
12607   
12608   
12609 -def fl_end_all_command(): 
12610      """ fl_end_all_command() -> num. 
12611      """ 
12612   
12613      _fl_end_all_command = cfuncproto( 
12614              load_so_libforms(), "fl_end_all_command", 
12615              cty.c_int, [], 
12616              """int fl_end_all_command() 
12617              """) 
12618      retval = _fl_end_all_command() 
12619      return retval 
12620   
12621   
12622 -def fl_show_command_log(p1): 
12623      """ fl_show_command_log(p1) 
12624      """ 
12625   
12626      _fl_show_command_log = cfuncproto( 
12627              load_so_libforms(), "fl_show_command_log", 
12628              None, [cty.c_int], 
12629              """void fl_show_command_log(int p1) 
12630              """) 
12631      ip1 = convert_to_int(p1) 
12632      keep_elem_refs(p1, ip1) 
12633      _fl_show_command_log(ip1) 
12634   
12635   
12636 -def fl_hide_command_log(): 
12637      """ fl_hide_command_log() 
12638      """ 
12639   
12640      _fl_hide_command_log = cfuncproto( 
12641              load_so_libforms(), "fl_hide_command_log", 
12642              None, [], 
12643              """void fl_hide_command_log() 
12644              """) 
12645      _fl_hide_command_log() 
12646   
12647   
12648 -def fl_clear_command_log(): 
12649      """ fl_clear_command_log() 
12650      """ 
12651   
12652      _fl_clear_command_log = cfuncproto( 
12653              load_so_libforms(), "fl_clear_command_log", 
12654              None, [], 
12655              """void fl_clear_command_log() 
12656              """) 
12657      _fl_clear_command_log() 
12658   
12659   
12660 -def fl_addto_command_log(p1): 
12661      """ fl_addto_command_log(p1) 
12662      """ 
12663   
12664      _fl_addto_command_log = cfuncproto( 
12665              load_so_libforms(), "fl_addto_command_log", 
12666              None, [STRING], 
12667              """void fl_addto_command_log(const char * p1) 
12668              """) 
12669      sp1 = convert_to_string(p1) 
12670      keep_elem_refs(p1, sp1) 
12671      _fl_addto_command_log(sp1) 
12672   
12673   
12674 -def fl_set_command_log_position(p1, p2): 
12675      """ fl_set_command_log_position(p1, p2) 
12676      """ 
12677   
12678      _fl_set_command_log_position = cfuncproto( 
12679              load_so_libforms(), "fl_set_command_log_position", 
12680              None, [cty.c_int, cty.c_int], 
12681              """void fl_set_command_log_position(int p1, int p2) 
12682              """) 
12683      ip1 = convert_to_int(p1) 
12684      ip2 = convert_to_int(p2) 
12685      keep_elem_refs(p1, p2, ip1, ip2) 
12686      _fl_set_command_log_position(ip1, ip2) 
12687   
12688   
12689 -def fl_get_command_log_fdstruct(): 
12690      """ fl_get_command_log_fdstruct() -> pCmdlog 
12691      """ 
12692   
12693      _fl_get_command_log_fdstruct = cfuncproto( 
12694              load_so_libforms(), "fl_get_command_log_fdstruct", 
12695              cty.POINTER(FD_CMDLOG), [], 
12696              """)FD_CMDLOG * fl_get_command_log_fdstruct() 
12697              """) 
12698      retval = _fl_get_command_log_fdstruct() 
12699      return retval 
12700   
12701   
12702  # aliases 
12703  fl_open_command = fl_exe_command 
12704  fl_close_command = fl_end_command 
12705   
12706   
12707  # file selector 
12708   
12709 -def fl_use_fselector(p1): 
12710      """ fl_use_fselector(p1) -> num. 
12711      """ 
12712   
12713      _fl_use_fselector = cfuncproto( 
12714              load_so_libforms(), "fl_use_fselector", 
12715              cty.c_int, [cty.c_int], 
12716              """int fl_use_fselector(int p1) 
12717              """) 
12718      ip1 = convert_to_int(p1) 
12719      keep_elem_refs(p1, ip1) 
12720      retval = _fl_use_fselector(ip1) 
12721      return retval 
12722   
12723   
12724 -def fl_show_fselector(p1, p2, p3, p4): 
12725      """ fl_show_fselector(p1, p2, p3, p4) -> fselector string 
12726      """ 
12727   
12728      _fl_show_fselector = cfuncproto( 
12729              load_so_libforms(), "fl_show_fselector", 
12730              STRING, [STRING, STRING, STRING, STRING], 
12731              """const char * fl_show_fselector(const char * p1, 
12732                 const char * p2, const char * p3, const char * p4) 
12733              """) 
12734      sp1 = convert_to_string(p1) 
12735      sp2 = convert_to_string(p2) 
12736      sp3 = convert_to_string(p3) 
12737      sp4 = convert_to_string(p4) 
12738      keep_elem_refs(p1, p2, p3, p4, sp1, sp2, sp3, sp4) 
12739      retval = _fl_show_fselector(sp1, sp2, sp3, sp4) 
12740      return retval 
12741   
12742   
12743 -def fl_set_fselector_fontsize(p1): 
12744      """ fl_set_fselector_fontsize(p1) 
12745      """ 
12746   
12747      _fl_set_fselector_fontsize = cfuncproto( 
12748              load_so_libforms(), "fl_set_fselector_fontsize", 
12749              None, [cty.c_int], 
12750              """void fl_set_fselector_fontsize(int p1) 
12751              """) 
12752      ip1 = convert_to_int(p1) 
12753      keep_elem_refs(p1, ip1) 
12754      _fl_set_fselector_fontsize(ip1) 
12755   
12756   
12757 -def fl_set_fselector_fontstyle(p1): 
12758      """ fl_set_fselector_fontstyle(p1) 
12759      """ 
12760   
12761      _fl_set_fselector_fontstyle = cfuncproto( 
12762              load_so_libforms(), "fl_set_fselector_fontstyle", 
12763              None, [cty.c_int], 
12764              """void fl_set_fselector_fontstyle(int p1) 
12765              """) 
12766      ip1 = convert_to_int(p1) 
12767      keep_elem_refs(p1, ip1) 
12768      _fl_set_fselector_fontstyle(ip1) 
12769   
12770   
12771 -def fl_set_fselector_placement(p1): 
12772      """ fl_set_fselector_placement(p1) 
12773      """ 
12774   
12775      _fl_set_fselector_placement = cfuncproto( 
12776              load_so_libforms(), "fl_set_fselector_placement", 
12777              None, [cty.c_int], 
12778              """void fl_set_fselector_placement(int p1) 
12779              """) 
12780      ip1 = convert_to_int(p1) 
12781      keep_elem_refs(p1, ip1) 
12782      _fl_set_fselector_placement(ip1) 
12783   
12784   
12785 -def fl_set_fselector_border(p1): 
12786      """ fl_set_fselector_border(p1) 
12787      """ 
12788   
12789      _fl_set_fselector_border = cfuncproto( 
12790              load_so_libforms(), "fl_set_fselector_border", 
12791              None, [cty.c_int], 
12792              """void fl_set_fselector_border(int p1) 
12793              """) 
12794      ip1 = convert_to_int(p1) 
12795      keep_elem_refs(p1, ip1) 
12796      _fl_set_fselector_border(ip1) 
12797   
12798   
12799 -def fl_set_fselector_transient(b): 
12800      if b: 
12801          argval = FL_TRANSIENT 
12802      else: 
12803          argval = FL_FULLBORDER 
12804      fl_set_fselector_border(argval) 
12805   
12806   
12807  FL_FSCB = cty.CFUNCTYPE(cty.c_int, STRING, cty.c_void_p) 
12808   
12809 -def fl_set_fselector_callback(py_FSCB, data): 
12810      """ 
12811          fl_set_fselector_callback(py_FSCB, data) 
12812      """ 
12813   
12814      _fl_set_fselector_callback = cfuncproto( 
12815              load_so_libforms(), "fl_set_fselector_callback", 
12816              None, [FL_FSCB, cty.c_void_p], 
12817              """void fl_set_fselector_callback(FL_FSCB p1, void * p2) 
12818              """) 
12819      c_FSCB = FL_FSCB(py_FSCB) 
12820      pdata = cty.cast(data, cty.c_void_p) 
12821      keep_cfunc_refs(c_FSCB, py_FSCB) 
12822      keep_elem_refs(data, pdata) 
12823      _fl_set_fselector_callback(c_FSCB, pdata) 
12824   
12825   
12826 -def fl_get_filename(): 
12827      """ fl_get_filename() -> filename string 
12828      """ 
12829   
12830      _fl_get_filename = cfuncproto( 
12831              load_so_libforms(), "fl_get_filename", 
12832              STRING, [], 
12833              """const char * fl_get_filename() 
12834              """) 
12835      retval = _fl_get_filename() 
12836      return retval 
12837   
12838   
12839 -def fl_get_directory(): 
12840      """ fl_get_directory() -> directory string 
12841      """ 
12842   
12843      _fl_get_directory = cfuncproto( 
12844              load_so_libforms(), "fl_get_directory", 
12845              STRING, [], 
12846              """const char * fl_get_directory() 
12847              """) 
12848      retval = _fl_get_directory() 
12849      return retval 
12850   
12851   
12852 -def fl_get_pattern(): 
12853      """ fl_get_pattern() -> pattern string 
12854      """ 
12855   
12856      _fl_get_pattern = cfuncproto( 
12857              load_so_libforms(), "fl_get_pattern", 
12858              STRING, [], 
12859              """const char * fl_get_pattern() 
12860              """) 
12861      retval = _fl_get_pattern() 
12862      return retval 
12863   
12864   
12865 -def fl_set_directory(p1): 
12866      """ fl_set_directory(p1) -> num. 
12867      """ 
12868   
12869      _fl_set_directory = cfuncproto( 
12870              load_so_libforms(), "fl_set_directory", 
12871              cty.c_int, [STRING], 
12872              """int fl_set_directory(const char * p1) 
12873              """) 
12874      sp1 = convert_to_string(p1) 
12875      keep_elem_refs(p1, sp1) 
12876      retval = _fl_set_directory(sp1) 
12877      return retval 
12878   
12879   
12880 -def fl_set_pattern(p1): 
12881      """ fl_set_pattern(p1) 
12882      """ 
12883   
12884      _fl_set_pattern = cfuncproto( 
12885              load_so_libforms(), "fl_set_pattern", 
12886              None, [STRING], 
12887              """void fl_set_pattern(const char * p1) 
12888              """) 
12889      sp1 = convert_to_string(p1) 
12890      keep_elem_refs(p1, sp1) 
12891      _fl_set_pattern(sp1) 
12892   
12893   
12894 -def fl_refresh_fselector(): 
12895      """ fl_refresh_fselector() 
12896      """ 
12897   
12898      _fl_refresh_fselector = cfuncproto( 
12899              load_so_libforms(), "fl_refresh_fselector", 
12900              None, [], 
12901              """void fl_refresh_fselector() 
12902              """) 
12903      _fl_refresh_fselector() 
12904   
12905   
12906  # c function prototype for _fl_add_fselector_appbutton 
12907  cfunc_none_voidp = cty.CFUNCTYPE(None, cty.c_void_p) 
12908   
12909 -def fl_add_fselector_appbutton(label, py_fn, data): 
12910      """ fl_add_fselector_appbutton(label, py_fn, data) 
12911      """ 
12912   
12913      _fl_add_fselector_appbutton = cfuncproto( 
12914              load_so_libforms(), "fl_add_fselector_appbutton", 
12915              None, [STRING, cfunc_none_voidp, cty.c_void_p], 
12916              """void fl_add_fselector_appbutton(const char * p1, 
12917                 const char * p2, void * p3) 
12918              """) 
12919      slabel = convert_to_string(label) 
12920      c_fn = cfunc_none_voidp(py_fn) 
12921      pdata = cty.cast(data, cty.c_void_p) 
12922      keep_cfunc_refs(c_fn, py_fn) 
12923      keep_elem_refs(label, data, slabel, pdata) 
12924      _fl_add_fselector_appbutton(slabel, c_fn, pdata) 
12925   
12926   
12927 -def fl_remove_fselector_appbutton(label): 
12928      """ fl_remove_fselector_appbutton(label) 
12929      """ 
12930   
12931      _fl_remove_fselector_appbutton = cfuncproto( 
12932              load_so_libforms(), "fl_remove_fselector_appbutton", 
12933              None, [STRING], 
12934              """void fl_remove_fselector_appbutton(const char * p1) 
12935              """) 
12936      slabel = convert_to_string(label) 
12937      keep_elem_refs(label, slabel) 
12938      _fl_remove_fselector_appbutton(slabel) 
12939   
12940   
12941 -def fl_disable_fselector_cache(yes): 
12942      """ fl_disable_fselector_cache(yes) 
12943      """ 
12944   
12945      _fl_disable_fselector_cache = cfuncproto( 
12946              load_so_libforms(), "fl_disable_fselector_cache", 
12947              None, [cty.c_int], 
12948              """void fl_disable_fselector_cache(int p1) 
12949              """) 
12950      iyes = convert_to_int(yes) 
12951      keep_elem_refs(yes, iyes) 
12952      _fl_disable_fselector_cache(iyes) 
12953   
12954   
12955 -def fl_invalidate_fselector_cache(): 
12956      """ fl_invalidate_fselector_cache() 
12957      """ 
12958   
12959      _fl_invalidate_fselector_cache = cfuncproto( 
12960              load_so_libforms(), "fl_invalidate_fselector_cache", 
12961              None, [], 
12962              """void fl_invalidate_fselector_cache() 
12963              """) 
12964      _fl_invalidate_fselector_cache() 
12965   
12966   
12967 -def fl_get_fselector_form(): 
12968      """ fl_get_fselector_form() -> pForm 
12969      """ 
12970   
12971      _fl_get_fselector_form = cfuncproto( 
12972              load_so_libforms(), "fl_get_fselector_form", 
12973              cty.POINTER(FL_FORM), [], 
12974              """FL_FORM * fl_get_fselector_form() 
12975              """) 
12976      retval = _fl_get_fselector_form() 
12977      return retval 
12978   
12979   
12980 -def fl_get_fselector_fdstruct(): 
12981      """ fl_get_fselector_fdstruct() -> fselector class 
12982      """ 
12983   
12984      _fl_get_fselector_fdstruct = cfuncproto( 
12985              load_so_libforms(), "fl_get_fselector_fdstruct", 
12986              cty.POINTER(FD_FSELECTOR), [], 
12987              """FD_FSELECTOR * fl_get_fselector_fdstruct() 
12988              """) 
12989      retval = _fl_get_fselector_fdstruct() 
12990      return retval 
12991   
12992   
12993 -def fl_hide_fselector(): 
12994      """ fl_hide_fselector() 
12995      """ 
12996   
12997      _fl_hide_fselector = cfuncproto( 
12998              load_so_libforms(), "fl_hide_fselector", 
12999              None, [], 
13000              """void fl_hide_fselector() 
13001              """) 
13002      _fl_hide_fselector() 
13003   
13004   
13005 -def fl_set_fselector_filetype_marker(p1, p2, p3, p4, p5): 
13006      """ fl_set_fselector_filetype_marker(p1, p2, p3, p4, p5) 
13007      """ 
13008   
13009      _fl_set_fselector_filetype_marker = cfuncproto( 
13010              load_so_libforms(), "fl_set_fselector_filetype_marker", 
13011              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int], 
13012              """void fl_set_fselector_filetype_marker(int p1, int p2, int p3, 
13013                 int p4, int p5) 
13014              """) 
13015      ip1 = convert_to_int(p1) 
13016      ip2 = convert_to_int(p2) 
13017      ip3 = convert_to_int(p3) 
13018      ip4 = convert_to_int(p4) 
13019      ip5 = convert_to_int(p5) 
13020      keep_elem_refs(p1, p2, p3, p4, p5, ip1, ip2, ip3, ip4, ip5) 
13021      _fl_set_fselector_filetype_marker(ip1, ip2, ip3, ip4, ip5) 
13022   
13023   
13024  fl_show_file_selector = fl_show_fselector 
13025  fl_set_fselector_cb = fl_set_fselector_callback 
13026   
13027   
13028 -def fl_set_fselector_title(title): 
13029      fl_set_form_title(fl_get_fselector_form(), title) 
13030   
13031   
13032 -def fl_goodies_atclose(pForm, data): 
13033      """ fl_goodies_atclose(pForm, data) -> num. 
13034      """ 
13035   
13036      _fl_goodies_atclose = cfuncproto( 
13037              load_so_libforms(), "fl_goodies_atclose", 
13038              cty.c_int, [cty.POINTER(FL_FORM), cty.c_void_p], 
13039              """int fl_goodies_atclose(FL_FORM * p1, void * p2) 
13040              """) 
13041      pdata = cty.cast(data, cty.c_void_p) 
13042      keep_elem_refs(pForm, data, pdata) 
13043      retval = _fl_goodies_atclose(pForm, pdata) 
13044      return retval 
13045   
13046   
13047   
13048  #################### 
13049  # forms.h (input.h) 
13050  #################### 
13051   
13052  # Routines 
13053   
13054 -def fl_create_input(inputtype, x, y, w, h, label): 
13055      """ fl_create_input(inputtype, x, y, w, h, label) -> pObject 
13056      """ 
13057   
13058      _fl_create_input = cfuncproto( 
13059              load_so_libforms(), "fl_create_input", 
13060              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
13061              FL_Coord, STRING], 
13062              """FL_OBJECT * fl_create_input(int type, FL_Coord x, FL_Coord y, 
13063                 FL_Coord w, FL_Coord h, const char * label) 
13064              """) 
13065      check_admitted_listvalues(inputtype, INPUTTYPE_list) 
13066      iinputtype = convert_to_int(inputtype) 
13067      ix = convert_to_FL_Coord(x) 
13068      iy = convert_to_FL_Coord(y) 
13069      iw = convert_to_FL_Coord(w) 
13070      ih = convert_to_FL_Coord(h) 
13071      slabel = convert_to_string(label) 
13072      keep_elem_refs(inputtype, x, y, w, h, label, iinputtype, ix, iy, 
13073                     iw, ih, slabel) 
13074      retval = _fl_create_input(iinputtype, ix, iy, iw, ih, slabel) 
13075      return retval 
13076   
13077   
13078 -def fl_add_input(inputtype, x, y, w, h, label): 
13079      """ fl_add_input(inputtype, x, y, w, h, label) -> pObject 
13080      """ 
13081   
13082      _fl_add_input = cfuncproto( 
13083              load_so_libforms(), "fl_add_input", 
13084              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
13085              FL_Coord, STRING], 
13086              """FL_OBJECT * fl_add_input(int type, FL_Coord x, FL_Coord y, 
13087                 FL_Coord w, FL_Coord h, const char * label) 
13088              """) 
13089      check_admitted_listvalues(inputtype, INPUTTYPE_list) 
13090      iinputtype = convert_to_int(inputtype) 
13091      ix = convert_to_FL_Coord(x) 
13092      iy = convert_to_FL_Coord(y) 
13093      iw = convert_to_FL_Coord(w) 
13094      ih = convert_to_FL_Coord(h) 
13095      slabel = convert_to_string(label) 
13096      keep_elem_refs(inputtype, x, y, w, h, label, iinputtype, ix, iy, 
13097                     iw, ih, slabel) 
13098      retval = _fl_add_input(iinputtype, ix, iy, iw, ih, slabel) 
13099      return retval 
13100   
13101   
13102 -def fl_set_input(pObject, inputstr): 
13103      """ fl_set_input(pObject, inputstr) 
13104      """ 
13105   
13106      _fl_set_input = cfuncproto( 
13107              load_so_libforms(), "fl_set_input", 
13108              None, [cty.POINTER(FL_OBJECT), STRING], 
13109              """void fl_set_input(FL_OBJECT * ob, const char * str) 
13110              """) 
13111      sinputstr = convert_to_string(inputstr) 
13112      keep_elem_refs(pObject, inputstr, sinputstr) 
13113      _fl_set_input(pObject, sinputstr) 
13114   
13115   
13116 -def fl_set_input_return(pObject, value): 
13117      """ fl_set_input_return(pObject, value) 
13118      """ 
13119   
13120      _fl_set_input_return = cfuncproto( 
13121              load_so_libforms(), "fl_set_input_return", 
13122              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13123              """void fl_set_input_return(FL_OBJECT * ob, int value) 
13124              """) 
13125      ivalue = convert_to_int(value) 
13126      keep_elem_refs(pObject, value, ivalue) 
13127      _fl_set_input_return(pObject, ivalue) 
13128   
13129   
13130 -def fl_set_input_color(pObject, textcolr, curscolr): 
13131      """ fl_set_input_color(pObject, textcolr, curscolr) 
13132      """ 
13133   
13134      _fl_set_input_color = cfuncproto( 
13135              load_so_libforms(), "fl_set_input_color", 
13136              None, [cty.POINTER(FL_OBJECT), FL_COLOR, FL_COLOR], 
13137              """void fl_set_input_color(FL_OBJECT * ob, FL_COLOR textcol, 
13138                 FL_COLOR curscol) 
13139              """) 
13140      ultextcolr = convert_to_FL_COLOR(textcolr) 
13141      ulcurscolr = convert_to_FL_COLOR(curscolr) 
13142      keep_elem_refs(pObject, textcolr, curscolr, ultextcolr, ulcurscolr) 
13143      _fl_set_input_color(pObject, ultextcolr, ulcurscolr) 
13144   
13145   
13146  #def fl_get_input_color(pObject, textcolr, curscolr)       *API change* 
13147 -def fl_get_input_color(pObject): 
13148      """ fl_get_input_color(pObject) -> textcolr, curscolr 
13149      """ 
13150   
13151      _fl_get_input_color = cfuncproto( 
13152              load_so_libforms(), "fl_get_input_color", 
13153              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_COLOR), 
13154              cty.POINTER(FL_COLOR)], 
13155              """void fl_get_input_color(FL_OBJECT * ob, FL_COLOR * textcol, 
13156                 FL_COLOR * curscol) 
13157              """) 
13158      textcolr, ptextcolr = make_ulong_and_pointer() 
13159      curscolr, pcurscolr = make_ulong_and_pointer() 
13160      keep_elem_refs(pObject, textcolr, curscolr) 
13161      _fl_get_input_color(pObject, ptextcolr, pcurscolr) 
13162      return textcolr, curscolr 
13163   
13164   
13165 -def fl_set_input_scroll(pObject, yes): 
13166      """ fl_set_input_scroll(pObject, yes) 
13167      """ 
13168   
13169      _fl_set_input_scroll = cfuncproto( 
13170              load_so_libforms(), "fl_set_input_scroll", 
13171              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13172              """void fl_set_input_scroll(FL_OBJECT * ob, int yes) 
13173              """) 
13174      iyes = convert_to_int(yes) 
13175      keep_elem_refs(pObject, yes, iyes) 
13176      _fl_set_input_scroll(pObject, iyes) 
13177   
13178   
13179 -def fl_set_input_cursorpos(pObject, xpos, ypos): 
13180      """ fl_set_input_cursorpos(pObject, xpos, ypos) 
13181      """ 
13182   
13183      _fl_set_input_cursorpos = cfuncproto( 
13184              load_so_libforms(), "fl_set_input_cursorpos", 
13185              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
13186              """void fl_set_input_cursorpos(FL_OBJECT * ob, int xpos, int ypos) 
13187              """) 
13188      ixpos = convert_to_int(xpos) 
13189      iypos = convert_to_int(ypos) 
13190      keep_elem_refs(pObject, xpos, ypos, ixpos, iypos) 
13191      _fl_set_input_cursorpos(pObject, ixpos, iypos) 
13192   
13193   
13194 -def fl_set_input_selected(pObject, yes): 
13195      """ fl_set_input_selected(pObject, yes) 
13196      """ 
13197   
13198      _fl_set_input_selected = cfuncproto( 
13199              load_so_libforms(), "fl_set_input_selected", 
13200              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13201              """void fl_set_input_selected(FL_OBJECT * ob, int yes) 
13202              """) 
13203      iyes = convert_to_int(yes) 
13204      keep_elem_refs(pObject, yes, iyes) 
13205      _fl_set_input_selected(pObject, iyes) 
13206   
13207   
13208 -def fl_set_input_selected_range(pObject, begin, end): 
13209      """ fl_set_input_selected_range(pObject, begin, end) 
13210      """ 
13211   
13212      _fl_set_input_selected_range = cfuncproto( 
13213              load_so_libforms(), "fl_set_input_selected_range", 
13214              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
13215              """void fl_set_input_selected_range(FL_OBJECT * ob, 
13216                 int begin, int end) 
13217              """) 
13218      ibegin = convert_to_int(begin) 
13219      iend = convert_to_int(end) 
13220      keep_elem_refs(pObject, begin, end, ibegin, iend) 
13221      _fl_set_input_selected_range(pObject, ibegin, iend) 
13222   
13223   
13224  #def fl_get_input_selected_range(pObject, begin, end)       *API change* 
13225 -def fl_get_input_selected_range(pObject): 
13226      """ fl_get_input_selected_range(pObject) -> string, begin, end 
13227      """ 
13228   
13229      _fl_get_input_selected_range = cfuncproto( 
13230              load_so_libforms(), "fl_get_input_selected_range", 
13231              STRING, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
13232              cty.POINTER(cty.c_int)], 
13233              """const char * fl_get_input_selected_range(FL_OBJECT * ob, 
13234                 int * begin, int * end) 
13235              """) 
13236      begin, pbegin = make_int_and_pointer() 
13237      end, pend = make_int_and_pointer() 
13238      keep_elem_refs(pObject, begin, end, pbegin, pend) 
13239      retval = _fl_get_input_selected_range(pObject, pbegin, pend) 
13240      return retval, begin, end 
13241   
13242   
13243 -def fl_set_input_maxchars(pObject, maxchars): 
13244      """ fl_set_input_maxchars(pObject, maxchars) 
13245      """ 
13246   
13247      _fl_set_input_maxchars = cfuncproto( 
13248              load_so_libforms(), "fl_set_input_maxchars", 
13249              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13250              """void fl_set_input_maxchars(FL_OBJECT * ob, int maxchars) 
13251              """) 
13252      imaxchars = convert_to_int(maxchars) 
13253      keep_elem_refs(pObject, maxchars, imaxchars) 
13254      _fl_set_input_maxchars(pObject, imaxchars) 
13255   
13256   
13257 -def fl_set_input_format(pObject, fmt, sep): 
13258      """ fl_set_input_format(pObject, fmt, sep) 
13259      """ 
13260   
13261      _fl_set_input_format = cfuncproto( 
13262              load_so_libforms(), "fl_set_input_format", 
13263              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
13264              """void fl_set_input_format(FL_OBJECT * ob, int fmt, int sep) 
13265              """) 
13266      ifmt = convert_to_int(fmt) 
13267      isep = convert_to_int(sep) 
13268      keep_elem_refs(pObject, fmt, sep, ifmt, isep) 
13269      _fl_set_input_format(pObject, ifmt, isep) 
13270   
13271   
13272 -def fl_set_input_hscrollbar(pObject, pref): 
13273      """ fl_set_input_hscrollbar(pObject, pref) 
13274      """ 
13275   
13276      _fl_set_input_hscrollbar = cfuncproto( 
13277              load_so_libforms(), "fl_set_input_hscrollbar", 
13278              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13279              """void fl_set_input_hscrollbar(FL_OBJECT * ob, int pref) 
13280              """) 
13281      ipref = convert_to_int(pref) 
13282      keep_elem_refs(pObject, pref, ipref) 
13283      _fl_set_input_hscrollbar(pObject, ipref) 
13284   
13285   
13286 -def fl_set_input_vscrollbar(pObject, pref): 
13287      """ fl_set_input_vscrollbar(pObject, pref) 
13288      """ 
13289   
13290      _fl_set_input_vscrollbar = cfuncproto( 
13291              load_so_libforms(), "fl_set_input_vscrollbar", 
13292              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13293              """void fl_set_input_vscrollbar(FL_OBJECT * ob, int pref) 
13294              """) 
13295      ipref = convert_to_int(pref) 
13296      keep_elem_refs(pObject, pref, ipref) 
13297      _fl_set_input_vscrollbar(pObject, ipref) 
13298   
13299   
13300 -def fl_set_input_topline(pObject, top): 
13301      """ fl_set_input_topline(pObject, top) 
13302      """ 
13303   
13304      _fl_set_input_topline = cfuncproto( 
13305              load_so_libforms(), "fl_set_input_topline", 
13306              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13307              """void fl_set_input_topline(FL_OBJECT * ob, int top) 
13308              """) 
13309      itop = convert_to_int(top) 
13310      keep_elem_refs(pObject, top, itop) 
13311      _fl_set_input_topline(pObject, itop) 
13312   
13313   
13314 -def fl_set_input_scrollbarsize(pObject, hh, vw): 
13315      """ fl_set_input_scrollbarsize(pObject, hh, vw) 
13316      """ 
13317   
13318      _fl_set_input_scrollbarsize = cfuncproto( 
13319              load_so_libforms(), "fl_set_input_scrollbarsize", 
13320              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
13321              """void fl_set_input_scrollbarsize(FL_OBJECT * ob, int hh, int vw) 
13322              """) 
13323      ihh = convert_to_int(hh) 
13324      ivw = convert_to_int(vw) 
13325      keep_elem_refs(pObject, hh, vw, ihh, ivw) 
13326      _fl_set_input_scrollbarsize(pObject, ihh, ivw) 
13327   
13328   
13329  #def fl_get_input_scrollbarsize(pObject, hh, vw)       *API change* 
13330 -def fl_get_input_scrollbarsize(pObject): 
13331      """ fl_get_input_scrollbarsize(pObject) -> hh, vw 
13332      """ 
13333   
13334      _fl_get_input_scrollbarsize = cfuncproto( 
13335              load_so_libforms(), "fl_get_input_scrollbarsize", 
13336              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
13337              cty.POINTER(cty.c_int)], 
13338              """void fl_get_input_scrollbarsize(FL_OBJECT * ob, 
13339                 int * hh, int * vw) 
13340              """) 
13341      hh, phh = make_int_and_pointer() 
13342      vw, pvw = make_int_and_pointer() 
13343      keep_elem_refs(pObject, hh, vw) 
13344      _fl_get_input_scrollbarsize(pObject, phh, pvw) 
13345      return hh, vw 
13346   
13347   
13348 -def fl_set_input_xoffset(pObject, xoff): 
13349      """ fl_set_input_xoffset(pObject, xoff) 
13350      """ 
13351   
13352      _fl_set_input_xoffset = cfuncproto( 
13353              load_so_libforms(), "fl_set_input_xoffset", 
13354              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13355              """void fl_set_input_xoffset(FL_OBJECT * ob, int xoff) 
13356              """) 
13357      ixoff = convert_to_int(xoff) 
13358      keep_elem_refs(pObject, xoff, ixoff) 
13359      _fl_set_input_xoffset(pObject, ixoff) 
13360   
13361   
13362 -def fl_get_input_xoffset(pObject): 
13363      """ fl_get_input_xoffset(pObject) -> num. 
13364      """ 
13365   
13366      _fl_get_input_xoffset = cfuncproto( 
13367              load_so_libforms(), "fl_get_input_xoffset", 
13368              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13369              """int fl_get_input_xoffset(FL_OBJECT * ob) 
13370              """) 
13371      keep_elem_refs(pObject) 
13372      retval = _fl_get_input_xoffset(pObject) 
13373      return retval 
13374   
13375   
13376 -def fl_set_input_fieldchar(pObject, fldchar): 
13377      """ fl_set_input_fieldchar(pObject, fldchar) -> num. 
13378      """ 
13379   
13380      _fl_set_input_fieldchar = cfuncproto( 
13381              load_so_libforms(), "fl_set_input_fieldchar", 
13382              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
13383              """int fl_set_input_fieldchar(FL_OBJECT * ob, int fchar) 
13384              """) 
13385      ifldchar = convert_to_int(fldchar) 
13386      keep_elem_refs(pObject, fldchar, ifldchar) 
13387      retval = _fl_set_input_fieldchar(pObject, ifldchar) 
13388      return retval 
13389   
13390   
13391 -def fl_get_input_topline(pObject): 
13392      """ fl_get_input_topline(pObject) -> num. 
13393      """ 
13394   
13395      _fl_get_input_topline = cfuncproto( 
13396              load_so_libforms(), "fl_get_input_topline", 
13397              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13398              """int fl_get_input_topline(FL_OBJECT * ob) 
13399              """) 
13400      keep_elem_refs(pObject) 
13401      retval = _fl_get_input_topline(pObject) 
13402      return retval 
13403   
13404   
13405 -def fl_get_input_screenlines(pObject): 
13406      """ fl_get_input_screenlines(pObject) -> num. 
13407      """ 
13408   
13409      _fl_get_input_screenlines = cfuncproto( 
13410              load_so_libforms(), "fl_get_input_screenlines", 
13411              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13412              """int fl_get_input_screenlines(FL_OBJECT * ob) 
13413              """) 
13414      keep_elem_refs(pObject) 
13415      retval = _fl_get_input_screenlines(pObject) 
13416      return retval 
13417   
13418   
13419  #def fl_get_input_cursorpos(pObject, x, y)       *API change* 
13420 -def fl_get_input_cursorpos(pObject): 
13421      """ fl_get_input_cursorpos(pObject) -> num., x, y 
13422      """ 
13423   
13424      _fl_get_input_cursorpos = cfuncproto( 
13425              load_so_libforms(), "fl_get_input_cursorpos", 
13426              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
13427              cty.POINTER(cty.c_int)], 
13428              """int fl_get_input_cursorpos(FL_OBJECT * ob, int * x, int * y) 
13429              """) 
13430      x, px = make_int_and_pointer() 
13431      y, py = make_int_and_pointer() 
13432      keep_elem_refs(pObject, x, y) 
13433      retval = _fl_get_input_cursorpos(pObject, px, py) 
13434      return retval, x, y 
13435   
13436   
13437 -def fl_set_input_cursor_visible(pObject, visible): 
13438      """ fl_set_input_cursor_visible(pObject, visible) 
13439      """ 
13440   
13441      _fl_set_input_cursor_visible = cfuncproto( 
13442              load_so_libforms(), "fl_set_input_cursor_visible", 
13443              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13444              """void fl_set_input_cursor_visible(FL_OBJECT * ob, int visible) 
13445              """) 
13446      ivisible = convert_to_int(visible) 
13447      keep_elem_refs(pObject, visible, ivisible) 
13448      _fl_set_input_cursor_visible(pObject, ivisible) 
13449   
13450   
13451 -def fl_get_input_numberoflines(pObject): 
13452      """ fl_get_input_numberoflines(pObject) -> lines num. 
13453      """ 
13454   
13455      _fl_get_input_numberoflines = cfuncproto( 
13456              load_so_libforms(), "fl_get_input_numberoflines", 
13457              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13458              """int fl_get_input_numberoflines(FL_OBJECT * ob) 
13459              """) 
13460      keep_elem_refs(pObject) 
13461      retval = _fl_get_input_numberoflines(pObject) 
13462      return retval 
13463   
13464   
13465  #def fl_get_input_format(pObject, fmt, sep)       *API change* 
13466 -def fl_get_input_format(pObject): 
13467      """ fl_get_input_format(pObject) -> fmt, sep 
13468      """ 
13469   
13470      _fl_get_input_format = cfuncproto( 
13471              load_so_libforms(), "fl_get_input_format", 
13472              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
13473              cty.POINTER(cty.c_int)], 
13474              """void fl_get_input_format(FL_OBJECT * ob, int * fmt, int * sep) 
13475              """) 
13476      fmt, pfmt = make_int_and_pointer() 
13477      sep, psep = make_int_and_pointer() 
13478      keep_elem_refs(pObject, fmt, sep, pfmt, psep) 
13479      _fl_get_input_format(pObject, pfmt, psep) 
13480      return fmt, sep 
13481   
13482   
13483 -def fl_get_input(pObject): 
13484      """ fl_get_input(pObject) -> input string 
13485      """ 
13486   
13487      _fl_get_input = cfuncproto( 
13488              load_so_libforms(), "fl_get_input", 
13489              STRING, [cty.POINTER(FL_OBJECT)], 
13490              """const char * fl_get_input(FL_OBJECT * ob) 
13491              """) 
13492      keep_elem_refs(pObject) 
13493      retval = _fl_get_input(pObject) 
13494      return retval 
13495   
13496   
13497  FL_INPUTVALIDATOR = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), STRING, 
13498                                    STRING, cty.c_int) 
13499   
13500 -def fl_set_input_filter(pObject, py_InputValidator): 
13501      """ 
13502          fl_set_input_filter(pObject, py_InputValidator) -> input_filter func. 
13503      """ 
13504   
13505      _fl_set_input_filter = cfuncproto( 
13506              load_so_libforms(), "fl_set_input_filter", 
13507              FL_INPUTVALIDATOR, [cty.POINTER(FL_OBJECT), FL_INPUTVALIDATOR], 
13508              """FL_INPUTVALIDATOR fl_set_input_filter(FL_OBJECT * ob, 
13509                 FL_INPUTVALIDATOR validate) 
13510              """) 
13511      c_InputValidator = FL_INPUTVALIDATOR(py_InputValidator) 
13512      keep_cfunc_refs(c_InputValidator, py_InputValidator) 
13513      keep_elem_refs(pObject) 
13514      retval = _fl_set_input_filter(pObject, c_InputValidator) 
13515      return retval 
13516   
13517   
13518 -def fl_validate_input(pObject): 
13519      """ fl_validate_input(pObject) -> num. 
13520      """ 
13521   
13522      _fl_validate_input = cfuncproto( 
13523              load_so_libforms(), "fl_validate_input", 
13524              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13525              """int fl_validate_input(FL_OBJECT * obj) 
13526              """) 
13527      keep_elem_refs(pObject) 
13528      retval = _fl_validate_input(pObject) 
13529      return retval 
13530   
13531   
13532  fl_set_input_shortcut = fl_set_object_shortcut 
13533   
13534   
13535  # edit keys 
13536   
13537 -def fl_set_input_editkeymap(pEditKeymap): 
13538      """ fl_set_input_editkeymap(pEditKeymap) 
13539      """ 
13540   
13541      _fl_set_input_editkeymap = cfuncproto( 
13542              load_so_libforms(), "fl_set_input_editkeymap", 
13543              None, [cty.POINTER(FL_EditKeymap)], 
13544              """void fl_set_input_editkeymap(const char * keymap) 
13545              """) 
13546      keep_elem_refs(pEditKeymap) 
13547      _fl_set_input_editkeymap(pEditKeymap) 
13548   
13549   
13550   
13551  ##################### 
13552  # forms.h (menu.h) 
13553  # Object Class: Menu 
13554  ##################### 
13555   
13556  # Routines 
13557   
13558 -def fl_create_menu(menutype, x, y, w, h, label): 
13559      """ fl_create_menu(menutype, x, y, w, h, label) -> pObject 
13560      """ 
13561   
13562      _fl_create_menu = cfuncproto( 
13563              load_so_libforms(), "fl_create_menu", 
13564              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
13565              FL_Coord, STRING], 
13566              """FL_OBJECT * fl_create_menu(int type, FL_Coord x, FL_Coord y, 
13567                 FL_Coord w, FL_Coord h, const char * label) 
13568              """) 
13569      check_admitted_listvalues(menutype, MENUTYPE_list) 
13570      imenutype = convert_to_int(menutype) 
13571      ix = convert_to_FL_Coord(x) 
13572      iy = convert_to_FL_Coord(y) 
13573      iw = convert_to_FL_Coord(w) 
13574      ih = convert_to_FL_Coord(h) 
13575      slabel = convert_to_string(label) 
13576      keep_elem_refs(menutype, x, y, w, h, label, imenutype, ix, iy, 
13577                     iw, ih, slabel) 
13578      retval = _fl_create_menu(imenutype, ix, iy, iw, ih, slabel) 
13579      return retval 
13580   
13581   
13582 -def fl_add_menu(menutype, x, y, w, h, label): 
13583      """ fl_add_menu(menutype, x, y, w, h, label) -> pObject 
13584      """ 
13585   
13586      _fl_add_menu = cfuncproto( 
13587              load_so_libforms(), "fl_add_menu", 
13588              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
13589              FL_Coord, STRING], 
13590              """FL_OBJECT * fl_add_menu(int type, FL_Coord x, FL_Coord y, 
13591                 FL_Coord w, FL_Coord h, const char * label)    DEPRECATED 
13592              """) 
13593      check_admitted_listvalues(menutype, MENUTYPE_list) 
13594      imenutype = convert_to_int(menutype) 
13595      ix = convert_to_FL_Coord(x) 
13596      iy = convert_to_FL_Coord(y) 
13597      iw = convert_to_FL_Coord(w) 
13598      ih = convert_to_FL_Coord(h) 
13599      slabel = convert_to_string(label) 
13600      keep_elem_refs(menutype, x, y, w, h, label, imenutype, ix, iy, 
13601                     iw, ih, slabel) 
13602      retval = _fl_add_menu(imenutype, ix, iy, iw, ih, slabel) 
13603      return retval 
13604   
13605   
13606 -def fl_clear_menu(pObject): 
13607      """ fl_clear_menu(pObject) 
13608      """ 
13609   
13610      _fl_clear_menu = cfuncproto( 
13611              load_so_libforms(), "fl_clear_menu", 
13612              None, [cty.POINTER(FL_OBJECT)], 
13613              """void fl_clear_menu(FL_OBJECT * ob)    DEPRECATED 
13614              """) 
13615      keep_elem_refs(pObject) 
13616      _fl_clear_menu(pObject) 
13617   
13618   
13619 -def fl_set_menu(pObject, menustr): 
13620      """ 
13621          fl_set_menu(pObject, menustr) 
13622   
13623          Sets the menu to a particular menu string. 
13624   
13625          @param pObject : pointer to menu object 
13626          @param menustr : text string of menu 
13627      """ 
13628   
13629      _fl_set_menu = cfuncproto( 
13630              load_so_libforms(), "fl_set_menu", 
13631              None, [cty.POINTER(FL_OBJECT), STRING], 
13632              """void fl_set_menu(FL_OBJECT * ob, const char * menustr)    DEPRECATED 
13633              """) 
13634      smenustr = convert_to_string(menustr) 
13635      keep_elem_refs(pObject, menustr, smenustr) 
13636      _fl_set_menu(pObject, smenustr) 
13637   
13638   
13639 -def fl_addto_menu(pObject, menustr): 
13640      """ fl_addto_menu(pObject, menustr) -> num. 
13641      """ 
13642   
13643      _fl_addto_menu = cfuncproto( 
13644              load_so_libforms(), "fl_addto_menu", 
13645              cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 
13646              """int fl_addto_menu(FL_OBJECT * ob, const char * menustr)    DEPRECATED 
13647              """) 
13648      smenustr = convert_to_string(menustr) 
13649      keep_elem_refs(pObject, menustr, smenustr) 
13650      retval = _fl_addto_menu(pObject, smenustr) 
13651      return retval 
13652   
13653   
13654 -def fl_replace_menu_item(pObject, numb, itemstr): 
13655      """ fl_replace_menu_item(pObject, numb, itemstr) 
13656      """ 
13657   
13658      _fl_replace_menu_item = cfuncproto( 
13659              load_so_libforms(), "fl_replace_menu_item", 
13660              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
13661              """void fl_replace_menu_item(FL_OBJECT * ob, int numb, 
13662                 const char * str)    DEPRECATED 
13663              """) 
13664      inumb = convert_to_int(numb) 
13665      sitemstr = convert_to_string(itemstr) 
13666      keep_elem_refs(pObject, numb, itemstr, inumb, sitemstr) 
13667      _fl_replace_menu_item(pObject, inumb, sitemstr) 
13668   
13669   
13670 -def fl_delete_menu_item(pObject, numb): 
13671      """ fl_delete_menu_item(pObject, numb) 
13672      """ 
13673   
13674      _fl_delete_menu_item = cfuncproto( 
13675              load_so_libforms(), "fl_delete_menu_item", 
13676              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13677              """void fl_delete_menu_item(FL_OBJECT * ob, int numb)    DEPRECATED 
13678              """) 
13679      inumb = convert_to_int(numb) 
13680      keep_elem_refs(pObject, numb, inumb) 
13681      _fl_delete_menu_item(pObject, inumb) 
13682   
13683   
13684  #already defined in xfdata 
13685  FL_PUP_CB = cty.CFUNCTYPE(cty.c_int, cty.c_int) 
13686   
13687 -def fl_set_menu_item_callback(pObject, numb, py_PupCb): 
13688      """ fl_set_menu_item_callback(pObject, numb, py_PupCb) -> callback 
13689      """ 
13690   
13691      _fl_set_menu_item_callback = cfuncproto( 
13692              load_so_libforms(), "fl_set_menu_item_callback", 
13693              FL_PUP_CB, [cty.POINTER(FL_OBJECT), cty.c_int, FL_PUP_CB], 
13694              """FL_PUP_CB fl_set_menu_item_callback(FL_OBJECT * ob, int numb, 
13695                 FL_PUP_CB cb) 
13696              """) 
13697      inumb = convert_to_int(numb) 
13698      c_PupCb = FL_PUP_CB(py_PupCb) 
13699      keep_cfunc_refs(c_PupCb, py_PupCb) 
13700      keep_elem_refs(pObject, numb, inumb) 
13701      retval = _fl_set_menu_item_callback(pObject, inumb, c_PupCb) 
13702      return retval 
13703   
13704   
13705 -def fl_set_menu_item_shortcut(pObject, itemnum, textsc): 
13706      """ 
13707          fl_set_menu_item_shortcut(pObject, itemnum, textsc) 
13708   
13709          Sets the shortcut of a menu item. 
13710   
13711          @param pObject : pointer to menu object 
13712          @param itemnum : item number to be operated on 
13713          @param textsc : text of shortcut to be set 
13714      """ 
13715   
13716      _fl_set_menu_item_shortcut = cfuncproto( 
13717              load_so_libforms(), "fl_set_menu_item_shortcut", 
13718              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
13719              """void fl_set_menu_item_shortcut(FL_OBJECT * ob, int numb, 
13720                 const char * str)   DEPRECATED 
13721              """) 
13722      iitemnum = convert_to_int(itemnum) 
13723      stextsc = convert_to_string(textsc) 
13724      keep_elem_refs(pObject, itemnum, stextsc, iitemnum, stextsc) 
13725      _fl_set_menu_item_shortcut(pObject, iitemnum, stextsc) 
13726   
13727   
13728 -def fl_set_menu_item_mode(pObject, itemnum, mode): 
13729      """ 
13730          fl_set_menu_item_mode(pObject, itemnum, mode) 
13731   
13732          Sets the mode of a menu item. 
13733   
13734          @param pObject : pointer to menu object 
13735          @param itemnum : id of an item to be operated on 
13736          @param mode : mode to be set 
13737      """ 
13738   
13739      _fl_set_menu_item_mode = cfuncproto( 
13740              load_so_libforms(), "fl_set_menu_item_mode", 
13741              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_uint], 
13742              """void fl_set_menu_item_mode(FL_OBJECT * ob, int numb, 
13743                 unsigned int mode)   DEPRECATED 
13744              """) 
13745      iitemnum = convert_to_int(itemnum) 
13746      uimode = convert_to_uint(mode) 
13747      keep_elem_refs(pObject, itemnum, mode, iitemnum, uimode) 
13748      _fl_set_menu_item_mode(pObject, iitemnum, uimode) 
13749   
13750   
13751 -def fl_show_menu_symbol(pObject, showflag): 
13752      """ 
13753          fl_show_menu_symbol(pObject, showflag) 
13754   
13755          Makes the menu symbol visible or not. 
13756   
13757          @param pObject : pointer to menu object 
13758          @param showflag : flag to show menu or not (1|0) 
13759      """ 
13760   
13761      _fl_show_menu_symbol = cfuncproto( 
13762              load_so_libforms(), "fl_show_menu_symbol", 
13763              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13764              """void fl_show_menu_symbol(FL_OBJECT * ob, int show)   DEPRECATED 
13765              """) 
13766      ishowflag = convert_to_int(showflag) 
13767      keep_elem_refs(pObject, showflag, ishowflag) 
13768      _fl_show_menu_symbol(pObject, ishowflag) 
13769   
13770   
13771 -def fl_set_menu_popup(pObject, pup): 
13772      """ fl_set_menu_popup(pObject, pup) 
13773      """ 
13774   
13775      _fl_set_menu_popup = cfuncproto( 
13776              load_so_libforms(), "fl_set_menu_popup", 
13777              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13778              """void fl_set_menu_popup(FL_OBJECT * ob, int pup)   DEPRECATED 
13779              """) 
13780      ipup = convert_to_int(pup) 
13781      keep_elem_refs(pObject, pup, ipup) 
13782      _fl_set_menu_popup(pObject, ipup) 
13783   
13784   
13785 -def fl_get_menu_popup(pObject): 
13786      """ fl_get_menu_popup(pObject) -> num. 
13787      """ 
13788   
13789      _fl_get_menu_popup = cfuncproto( 
13790              load_so_libforms(), "fl_get_menu_popup", 
13791              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13792              """int fl_get_menu_popup(FL_OBJECT * ob)   DEPRECATED 
13793              """) 
13794      keep_elem_refs(pObject) 
13795      retval = _fl_get_menu_popup(pObject) 
13796      return retval 
13797   
13798   
13799 -def fl_get_menu(pObject): 
13800      """ fl_get_menu(pObject) -> num. 
13801      """ 
13802   
13803      _fl_get_menu = cfuncproto( 
13804              load_so_libforms(), "fl_get_menu", 
13805              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13806              """int fl_get_menu(FL_OBJECT * ob)    DEPRECATED 
13807              """) 
13808      keep_elem_refs(pObject) 
13809      retval = _fl_get_menu(pObject) 
13810      return retval 
13811   
13812   
13813 -def fl_get_menu_item_text(pObject, numb): 
13814      """ fl_get_menu_item_text(pObject, numb) -> text string 
13815      """ 
13816   
13817      _fl_get_menu_item_text = cfuncproto( 
13818              load_so_libforms(), "fl_get_menu_item_text", 
13819              STRING, [cty.POINTER(FL_OBJECT), cty.c_int], 
13820              """const char * fl_get_menu_item_text(FL_OBJECT * ob, int numb)    DEPRECATED 
13821              """) 
13822      inumb = convert_to_int(numb) 
13823      keep_elem_refs(pObject, numb, inumb) 
13824      retval = _fl_get_menu_item_text(pObject, inumb) 
13825      return retval 
13826   
13827   
13828 -def fl_get_menu_maxitems(pObject): 
13829      """ fl_get_menu_maxitems(pObject) -> items num. 
13830      """ 
13831   
13832      _fl_get_menu_maxitems = cfuncproto( 
13833              load_so_libforms(), "fl_get_menu_maxitems", 
13834              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13835              """int fl_get_menu_maxitems(FL_OBJECT * ob)    DEPRECATED 
13836              """) 
13837      keep_elem_refs(pObject) 
13838      retval = _fl_get_menu_maxitems(pObject) 
13839      return retval 
13840   
13841   
13842 -def fl_get_menu_item_mode(pObject, numb): 
13843      """ fl_get_menu_item_mode(pObject, numb) -> mode num. 
13844      """ 
13845   
13846      _fl_get_menu_item_mode = cfuncproto( 
13847              load_so_libforms(), "fl_get_menu_item_mode", 
13848              cty.c_uint, [cty.POINTER(FL_OBJECT), cty.c_int], 
13849              """unsigned int fl_get_menu_item_mode(FL_OBJECT * ob, int numb)   DEPRECATED 
13850              """) 
13851      inumb = convert_to_int(numb) 
13852      keep_elem_refs(pObject, numb, inumb) 
13853      retval = _fl_get_menu_item_mode(pObject, inumb) 
13854      return retval 
13855   
13856   
13857 -def fl_get_menu_text(pObject): 
13858      """ fl_get_menu_text(pObject) -> text string 
13859      """ 
13860   
13861      _fl_get_menu_text = cfuncproto( 
13862              load_so_libforms(), "fl_get_menu_text", 
13863              STRING, [cty.POINTER(FL_OBJECT)], 
13864              """const char * fl_get_menu_text(FL_OBJECT * ob)    DEPRECATED 
13865              """) 
13866      keep_elem_refs(pObject) 
13867      retval = _fl_get_menu_text(pObject) 
13868      return retval 
13869   
13870   
13871 -def fl_set_menu_entries(pObject, pPopupEntry): 
13872      """ fl_set_menu_entries(pObject, pPopupEntry) -> num. 
13873      """ 
13874   
13875      _fl_set_menu_entries = cfuncproto( 
13876              load_so_libforms(), "fl_set_menu_entries", 
13877              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_PUP_ENTRY)], 
13878              """int fl_set_menu_entries(FL_OBJECT * ob, FL_PUP_ENTRY * ent)    DEPRECATED 
13879              """) 
13880      keep_elem_refs(pObject, pPopupEntry) 
13881      retval = _fl_set_menu_entries(pObject, pPopupEntry) 
13882      return retval 
13883   
13884   
13885 -def fl_set_menu_notitle(pObject, off): 
13886      """ fl_set_menu_notitle(pObject, off) -> num. 
13887      """ 
13888   
13889      _fl_set_menu_notitle = cfuncproto( 
13890              load_so_libforms(), "fl_set_menu_notitle", 
13891              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
13892              """int fl_set_menu_notitle(FL_OBJECT * ob, int off)   DEPRECATED? 
13893              """) 
13894      ioff = convert_to_int(off) 
13895      keep_elem_refs(pObject, off, ioff) 
13896      retval = _fl_set_menu_notitle(pObject, ioff) 
13897      return retval 
13898   
13899   
13900 -def fl_set_menu_item_id(pObject, item, idnum): 
13901      """ fl_set_menu_item_id(pObject, item, idnum) -> num. 
13902      """ 
13903   
13904      _fl_set_menu_item_id = cfuncproto( 
13905              load_so_libforms(), "fl_set_menu_item_id", 
13906              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
13907              """int fl_set_menu_item_id(FL_OBJECT * ob, int item, int id) 
13908              """) 
13909      iitem = convert_to_int(item) 
13910      iidnum = convert_to_int(idnum) 
13911      keep_elem_refs(pObject, item, idnum, iitem, iidnum) 
13912      retval = _fl_set_menu_item_id(pObject, iitem, iidnum) 
13913      return retval 
13914   
13915   
13916   
13917  # Nmenu object types 
13918   
13919 -def fl_create_nmenu(nmenutype, x, y, w, h, label): 
13920      """ 
13921          fl_create_nmenu(nmenutype, x, y, w, h, label) -> pObject 
13922   
13923          Creates a nmenu object. 
13924   
13925          @param nmenutype : type of nmenu 
13926          @param x : horizontal position of nmenu (upper-left corner) 
13927          @param y : vertical position of nmenu (upper-left corner) 
13928          @param w : width of nmenu object in pixel 
13929          @param h : height of nmenu object in pixel 
13930          @param label : text label of nmenu object 
13931      """ 
13932   
13933      _fl_create_nmenu = cfuncproto( 
13934              load_so_libforms(), "fl_create_nmenu", 
13935              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
13936              FL_Coord, STRING], 
13937              """FL_OBJECT * fl_create_nmenu(int p1, FL_Coord p2, FL_Coord p3, 
13938                 FL_Coord p4, FL_Coord p5, const char * p6) 
13939              """) 
13940      check_admitted_listvalues(nmenutype, NMENUTYPE_list) 
13941      inmenutype = convert_to_int(nmenutype) 
13942      ix = convert_to_FL_Coord(x) 
13943      iy = convert_to_FL_Coord(y) 
13944      iw = convert_to_FL_Coord(w) 
13945      ih = convert_to_FL_Coord(h) 
13946      slabel = convert_to_string(label) 
13947      keep_elem_refs(nmenutype, x, y, w, h, label, inmenutype, ix, iy, 
13948                     iw, ih, slabel) 
13949      retval = _fl_create_nmenu(inmenutype, ix, iy, iw, ih, slabel) 
13950      return retval 
13951   
13952   
13953 -def fl_add_nmenu(nmenutype, x, y, w, h, label): 
13954      """ 
13955          fl_add_nmenu(nmenutype, x, y, w, h, label) -> pObject 
13956   
13957          Adds a nmenu object. 
13958   
13959          @param nmenutype : type of nmenu object 
13960          @param x : horizontal position of nmenu (upper-left corner) 
13961          @param y : vertical position of nmenu (upper-left corner) 
13962          @param w : width of nmenu object in pixel 
13963          @param h : height of nmenu object in pixel 
13964          @param label : text label of nmenu object 
13965      """ 
13966   
13967      _fl_add_nmenu = cfuncproto( 
13968              load_so_libforms(), "fl_add_nmenu", 
13969              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
13970              FL_Coord, STRING], 
13971              """FL_OBJECT * fl_add_nmenu(int p1, FL_Coord p2, FL_Coord p3, 
13972                 FL_Coord p4, FL_Coord p5, const char * p6) 
13973              """) 
13974      check_admitted_listvalues(nmenutype, NMENUTYPE_list) 
13975      inmenutype = convert_to_int(nmenutype) 
13976      ix = convert_to_FL_Coord(x) 
13977      iy = convert_to_FL_Coord(y) 
13978      iw = convert_to_FL_Coord(w) 
13979      ih = convert_to_FL_Coord(h) 
13980      slabel = convert_to_string(label) 
13981      keep_elem_refs(nmenutype, x, y, w, h, label, inmenutype, ix, iy, 
13982                     iw, ih, slabel) 
13983      retval = _fl_add_nmenu(inmenutype, ix, iy, iw, ih, slabel) 
13984      return retval 
13985   
13986   
13987 -def fl_clear_nmenu(pObject): 
13988      """ fl_clear_nmenu(pObject) -> num. 
13989      """ 
13990   
13991      _fl_clear_nmenu = cfuncproto( 
13992              load_so_libforms(), "fl_clear_nmenu", 
13993              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13994              """int fl_clear_nmenu(FL_OBJECT * p1) 
13995              """) 
13996      keep_elem_refs(pObject) 
13997      retval = _fl_clear_nmenu(pObject) 
13998      return retval 
13999   
14000   
14001 -def fl_add_nmenu_items(pObject, itemstr): 
14002      """ fl_add_nmenu_items(pObject, itemstr) -> pPopupEntry 
14003      """ 
14004   
14005      _fl_add_nmenu_items = cfuncproto( 
14006              load_so_libforms(), "fl_add_nmenu_items", 
14007              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 
14008              """FL_POPUP_ENTRY * fl_add_nmenu_items(FL_OBJECT * p1, 
14009                 const char * p2) 
14010              """) 
14011      sitemstr = convert_to_string(itemstr) 
14012      keep_elem_refs(pObject, itemstr, sitemstr) 
14013      retval = _fl_add_nmenu_items(pObject, sitemstr) 
14014      return retval 
14015   
14016   
14017 -def fl_insert_nmenu_items(pObject, pPopupEntry, itemstr): 
14018      """ fl_insert_nmenu_items(pObject, pPopupEntry, itemstr) -> pPopupEntry 
14019      """ 
14020   
14021      _fl_insert_nmenu_items = cfuncproto( 
14022              load_so_libforms(), "fl_insert_nmenu_items", 
14023              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 
14024              cty.POINTER(FL_POPUP_ENTRY), STRING], 
14025              """FL_POPUP_ENTRY * fl_insert_nmenu_items(FL_OBJECT * p1, 
14026                 FL_POPUP_ENTRY * p2, const char * p3) 
14027              """) 
14028      sitemstr = convert_to_string(itemstr) 
14029      keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 
14030      retval = _fl_insert_nmenu_items(pObject, pPopupEntry, sitemstr) 
14031      return retval 
14032   
14033   
14034 -def fl_replace_nmenu_item(pObject, pPopupEntry, itemstr): 
14035      """ fl_replace_nmenu_item(pObject, pPopupEntry, itemstr) -> pPopupEntry 
14036      """ 
14037   
14038      _fl_replace_nmenu_item = cfuncproto( 
14039              load_so_libforms(), "fl_replace_nmenu_item", 
14040              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 
14041              cty.POINTER(FL_POPUP_ENTRY), STRING], 
14042              """FL_POPUP_ENTRY * fl_replace_nmenu_item(FL_OBJECT * p1, 
14043                 FL_POPUP_ENTRY * p2, const char * p3) 
14044              """) 
14045      sitemstr = convert_to_string(itemstr) 
14046      keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 
14047      retval = _fl_replace_nmenu_item(pObject, pPopupEntry, sitemstr) 
14048      return retval 
14049   
14050   
14051 -def fl_delete_nmenu_item(pObject, pPopupEntry): 
14052      """ fl_delete_nmenu_item(pObject, pPopupEntry) -> num. 
14053      """ 
14054   
14055      _fl_delete_nmenu_item = cfuncproto( 
14056              load_so_libforms(), "fl_delete_nmenu_item", 
14057              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP_ENTRY)], 
14058              """int fl_delete_nmenu_item(FL_OBJECT * p1, FL_POPUP_ENTRY * p2) 
14059              """) 
14060      keep_elem_refs(pObject, pPopupEntry) 
14061      retval = _fl_delete_nmenu_item(pObject, pPopupEntry) 
14062      return retval 
14063   
14064   
14065 -def fl_set_nmenu_items(pObject, pPopupItem): 
14066      """ fl_set_nmenu_items(pObject, pPopupItem) -> pPopupEntry 
14067      """ 
14068   
14069      _fl_set_nmenu_items = cfuncproto( 
14070              load_so_libforms(), "fl_set_nmenu_items", 
14071              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 
14072              cty.POINTER(FL_POPUP_ITEM)], 
14073              """FL_POPUP_ENTRY * fl_set_nmenu_items(FL_OBJECT * p1, 
14074                 FL_POPUP_ITEM * p2) 
14075              """) 
14076      keep_elem_refs(pObject, pPopupItem) 
14077      retval = _fl_set_nmenu_items(pObject, pPopupItem) 
14078      return retval 
14079   
14080   
14081 -def fl_get_nmenu_popup(pObject): 
14082      """ fl_get_nmenu_popup(pObject) -> pPopup 
14083      """ 
14084   
14085      _fl_get_nmenu_popup = cfuncproto( 
14086              load_so_libforms(), "fl_get_nmenu_popup", 
14087              cty.POINTER(FL_POPUP), [cty.POINTER(FL_OBJECT)], 
14088              """FL_POPUP * fl_get_nmenu_popup(FL_OBJECT * p1) 
14089              """) 
14090      keep_elem_refs(pObject) 
14091      retval = _fl_get_nmenu_popup(pObject) 
14092      return retval 
14093   
14094   
14095 -def fl_set_nmenu_popup(pObject, pPopup): 
14096      """ fl_set_nmenu_popup(pObject, pPopup) -> num. 
14097      """ 
14098   
14099      _fl_set_nmenu_popup = cfuncproto( 
14100              load_so_libforms(), "fl_set_nmenu_popup", 
14101              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP)], 
14102              """int fl_set_nmenu_popup(FL_OBJECT * p1, FL_POPUP * p2) 
14103              """) 
14104      keep_elem_refs(pObject, pPopup) 
14105      retval = _fl_set_nmenu_popup(pObject, pPopup) 
14106      return retval 
14107   
14108   
14109 -def fl_get_nmenu_item(pObject): 
14110      """ fl_get_nmenu_item(pObject) -> pPopupReturn 
14111      """ 
14112   
14113      _fl_get_nmenu_item = cfuncproto( 
14114              load_so_libforms(), "fl_get_nmenu_item", 
14115              cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_OBJECT)], 
14116              """FL_POPUP_RETURN * fl_get_nmenu_item(FL_OBJECT * p1) 
14117              """) 
14118      keep_elem_refs(pObject) 
14119      retval = _fl_get_nmenu_item(pObject) 
14120      return retval 
14121   
14122   
14123 -def fl_get_nmenu_item_by_value(pObject, value): 
14124      """ fl_get_nmenu_item_by_value(pObject, value) -> pPopupEntry 
14125      """ 
14126   
14127      _fl_get_nmenu_item_by_value = cfuncproto( 
14128              load_so_libforms(), "fl_get_nmenu_item_by_value", 
14129              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), cty.c_long], 
14130              """FL_POPUP_ENTRY * fl_get_nmenu_item_by_value(FL_OBJECT * p1, 
14131                 long int p2) 
14132              """) 
14133      lvalue = convert_to_long(value) 
14134      keep_elem_refs(pObject, value, lvalue) 
14135      retval = _fl_get_nmenu_item_by_value(pObject, lvalue) 
14136      return retval 
14137   
14138   
14139 -def fl_get_nmenu_item_by_label(pObject, label): 
14140      """ fl_get_nmenu_item_by_label(pObject, label) -> pPopupEntry 
14141      """ 
14142   
14143      _fl_get_nmenu_item_by_label = cfuncproto( 
14144              load_so_libforms(), "fl_get_nmenu_item_by_label", 
14145              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 
14146              """FL_POPUP_ENTRY * fl_get_nmenu_item_by_label(FL_OBJECT * p1, 
14147                 const char * p2) 
14148              """) 
14149      slabel = convert_to_string(label) 
14150      keep_elem_refs(pObject, label, slabel) 
14151      retval = _fl_get_nmenu_item_by_label(pObject, slabel) 
14152      return retval 
14153   
14154   
14155 -def fl_get_nmenu_item_by_text(pObject, text): 
14156      """ fl_get_nmenu_item_by_text(pObject, text) -> pPopupEntry 
14157      """ 
14158   
14159      _fl_get_nmenu_item_by_text = cfuncproto( 
14160              load_so_libforms(), "fl_get_nmenu_item_by_text", 
14161              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 
14162              """FL_POPUP_ENTRY * fl_get_nmenu_item_by_text(FL_OBJECT * p1, 
14163                 const char * p2) 
14164              """) 
14165      stext = convert_to_string(text) 
14166      keep_elem_refs(pObject, text, stext) 
14167      retval = _fl_get_nmenu_item_by_text(pObject, stext) 
14168      return retval 
14169   
14170   
14171 -def fl_set_nmenu_policy(pObject, num): 
14172      """ fl_set_nmenu_policy(pObject, num) -> num. 
14173      """ 
14174   
14175      _fl_set_nmenu_policy = cfuncproto( 
14176              load_so_libforms(), "fl_set_nmenu_policy", 
14177              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
14178              """int fl_set_nmenu_policy(FL_OBJECT * p1, int p2) 
14179              """) 
14180      inum = convert_to_int(num) 
14181      keep_elem_refs(pObject, num, inum) 
14182      retval = _fl_set_nmenu_policy(pObject, inum) 
14183      return retval 
14184   
14185   
14186 -def fl_set_nmenu_hl_text_color(pObject, colr): 
14187      """ fl_set_nmenu_hl_text_color(pObject, colr) -> color 
14188      """ 
14189   
14190      _fl_set_nmenu_hl_text_color = cfuncproto( 
14191              load_so_libforms(), "fl_set_nmenu_hl_text_color", 
14192              FL_COLOR, [cty.POINTER(FL_OBJECT), FL_COLOR], 
14193              """FL_COLOR fl_set_nmenu_hl_text_color(FL_OBJECT * p1, 
14194                 FL_COLOR p2) 
14195              """) 
14196      ulcolr = convert_to_FL_COLOR(colr) 
14197      keep_elem_refs(pObject, colr, ulcolr) 
14198      retval = _fl_set_nmenu_hl_text_color(pObject, ulcolr) 
14199      return retval 
14200   
14201   
14202   
14203  ######################### 
14204  # forms.h (positioner.h) 
14205  ######################### 
14206   
14207  # Routines 
14208   
14209 -def fl_create_positioner(postype, x, y, w, h, label): 
14210      """ fl_create_positioner(postype, x, y, w, h, label) -> pObject 
14211      """ 
14212   
14213      _fl_create_positioner = cfuncproto( 
14214              load_so_libforms(), "fl_create_positioner", 
14215              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
14216              FL_Coord, STRING], 
14217              """FL_OBJECT * fl_create_positioner(int type, FL_Coord x, 
14218                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
14219              """) 
14220      check_admitted_listvalues(postype, POSITIONERTYPE_list) 
14221      ipostype = convert_to_int(postype) 
14222      ix = convert_to_FL_Coord(x) 
14223      iy = convert_to_FL_Coord(y) 
14224      iw = convert_to_FL_Coord(w) 
14225      ih = convert_to_FL_Coord(h) 
14226      slabel = convert_to_string(label) 
14227      keep_elem_refs(postype, x, y, w, h, label, ipostype, ix, iy, 
14228                     iw, ih, slabel) 
14229      retval = _fl_create_positioner(ipostype, ix, iy, iw, ih, slabel) 
14230      return retval 
14231   
14232   
14233 -def fl_add_positioner(postype, x, y, w, h, label): 
14234      """ fl_add_positioner(postype, x, y, w, h, label) -> pObject 
14235      """ 
14236   
14237      _fl_add_positioner = cfuncproto( 
14238              load_so_libforms(), "fl_add_positioner", 
14239              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
14240              FL_Coord, STRING], 
14241              """FL_OBJECT * fl_add_positioner(int type, FL_Coord x, FL_Coord y, 
14242                 FL_Coord w, FL_Coord h, const char * label) 
14243              """) 
14244      check_admitted_listvalues(postype, POSITIONERTYPE_list) 
14245      ipostype = convert_to_int(postype) 
14246      ix = convert_to_FL_Coord(x) 
14247      iy = convert_to_FL_Coord(y) 
14248      iw = convert_to_FL_Coord(w) 
14249      ih = convert_to_FL_Coord(h) 
14250      slabel = convert_to_string(label) 
14251      keep_elem_refs(postype, x, y, w, h, label, ipostype, ix, iy, 
14252                     iw, ih, slabel) 
14253      retval = _fl_add_positioner(ipostype, ix, iy, iw, ih, slabel) 
14254      return retval 
14255   
14256   
14257 -def fl_set_positioner_xvalue(pObject, val): 
14258      """ fl_set_positioner_xvalue(pObject, val) 
14259      """ 
14260   
14261      _fl_set_positioner_xvalue = cfuncproto( 
14262              load_so_libforms(), "fl_set_positioner_xvalue", 
14263              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14264              """void fl_set_positioner_xvalue(FL_OBJECT * ob, double val) 
14265              """) 
14266      fval = convert_to_double(val) 
14267      keep_elem_refs(pObject, val, fval) 
14268      _fl_set_positioner_xvalue(pObject, fval) 
14269   
14270   
14271 -def fl_get_positioner_xvalue(pObject): 
14272      """ fl_get_positioner_xvalue(pObject) -> floatnum 
14273      """ 
14274   
14275      _fl_get_positioner_xvalue = cfuncproto( 
14276              load_so_libforms(), "fl_get_positioner_xvalue", 
14277              cty.c_double, [cty.POINTER(FL_OBJECT)], 
14278              """double fl_get_positioner_xvalue(FL_OBJECT * ob) 
14279              """) 
14280      keep_elem_refs(pObject) 
14281      retval = _fl_get_positioner_xvalue(pObject) 
14282      return retval 
14283   
14284   
14285 -def fl_set_positioner_xbounds(pObject, minbound, maxbound): 
14286      """ fl_set_positioner_xbounds(pObject, minbound, maxbound) 
14287      """ 
14288   
14289      _fl_set_positioner_xbounds = cfuncproto( 
14290              load_so_libforms(), "fl_set_positioner_xbounds", 
14291              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
14292              """void fl_set_positioner_xbounds(FL_OBJECT * ob, double min, 
14293                 double max) 
14294              """) 
14295      fminbound = convert_to_double(minbound) 
14296      fmaxbound = convert_to_double(maxbound) 
14297      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
14298      _fl_set_positioner_xbounds(pObject, fminbound, fmaxbound) 
14299   
14300   
14301  #def fl_get_positioner_xbounds(pObject, minbound, maxbound)       *API change* 
14302 -def fl_get_positioner_xbounds(pObject): 
14303      """ fl_get_positioner_xbounds(pObject) -> minbound, maxbound 
14304      """ 
14305   
14306      _fl_get_positioner_xbounds = cfuncproto( 
14307              load_so_libforms(), "fl_get_positioner_xbounds", 
14308              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
14309              cty.POINTER(cty.c_double)], 
14310              """void fl_get_positioner_xbounds(FL_OBJECT * ob, double * min, 
14311              double * max) 
14312              """) 
14313      minbound, pminbound = make_double_and_pointer() 
14314      maxbound, pmaxbound = make_double_and_pointer() 
14315      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
14316      _fl_get_positioner_xbounds(pObject, pminbound, pmaxbound) 
14317      return minbound, maxbound 
14318   
14319   
14320 -def fl_set_positioner_yvalue(pObject, val): 
14321      """ fl_set_positioner_yvalue(pObject, val) 
14322      """ 
14323   
14324      _fl_set_positioner_yvalue = cfuncproto( 
14325              load_so_libforms(), "fl_set_positioner_yvalue", 
14326              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14327              """void fl_set_positioner_yvalue(FL_OBJECT * ob, double val) 
14328              """) 
14329      fval = convert_to_double(val) 
14330      keep_elem_refs(pObject, val, fval) 
14331      _fl_set_positioner_yvalue(pObject, fval) 
14332   
14333   
14334 -def fl_get_positioner_yvalue(pObject): 
14335      """ fl_get_positioner_yvalue(pObject) -> floatnum 
14336      """ 
14337   
14338      _fl_get_positioner_yvalue = cfuncproto( 
14339              load_so_libforms(), "fl_get_positioner_yvalue", 
14340              cty.c_double, [cty.POINTER(FL_OBJECT)], 
14341              """double fl_get_positioner_yvalue(FL_OBJECT * ob) 
14342              """) 
14343      keep_elem_refs(pObject) 
14344      retval = _fl_get_positioner_yvalue(pObject) 
14345      return retval 
14346   
14347   
14348 -def fl_set_positioner_ybounds(pObject, minbound, maxbound): 
14349      """ fl_set_positioner_ybounds(pObject, minbound, maxbound) 
14350      """ 
14351   
14352      _fl_set_positioner_ybounds = cfuncproto( 
14353              load_so_libforms(), "fl_set_positioner_ybounds", 
14354              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
14355              """void fl_set_positioner_ybounds(FL_OBJECT * ob, double min, 
14356                 double max) 
14357              """) 
14358      fminbound = convert_to_double(minbound) 
14359      fmaxbound = convert_to_double(maxbound) 
14360      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
14361      _fl_set_positioner_ybounds(pObject, fminbound, fmaxbound) 
14362   
14363   
14364  #def fl_get_positioner_ybounds(pObject, minbound, maxbound)       *API change* 
14365 -def fl_get_positioner_ybounds(pObject): 
14366      """ fl_get_positioner_ybounds(pObject) -> minbound, maxbound 
14367      """ 
14368   
14369      _fl_get_positioner_ybounds = cfuncproto( 
14370              load_so_libforms(), "fl_get_positioner_ybounds", 
14371              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
14372              cty.POINTER(cty.c_double)], 
14373              """void fl_get_positioner_ybounds(FL_OBJECT * ob, double * min, 
14374                 double * max) 
14375              """) 
14376      minbound, pminbound = make_double_and_pointer() 
14377      maxbound, pmaxbound = make_double_and_pointer() 
14378      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
14379      _fl_get_positioner_ybounds(pObject, pminbound, pmaxbound) 
14380      return minbound, maxbound 
14381   
14382   
14383 -def fl_set_positioner_xstep(pObject, value): 
14384      """ fl_set_positioner_xstep(pObject, value) 
14385      """ 
14386   
14387      _fl_set_positioner_xstep = cfuncproto( 
14388              load_so_libforms(), "fl_set_positioner_xstep", 
14389              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14390              """void fl_set_positioner_xstep(FL_OBJECT * ob, double value) 
14391              """) 
14392      fvalue = convert_to_double(value) 
14393      keep_elem_refs(pObject, value, fvalue) 
14394      _fl_set_positioner_xstep(pObject, fvalue) 
14395   
14396   
14397 -def fl_set_positioner_ystep(pObject, value): 
14398      """ fl_set_positioner_ystep(pObject, value) 
14399      """ 
14400   
14401      _fl_set_positioner_ystep = cfuncproto( 
14402              load_so_libforms(), "fl_set_positioner_ystep", 
14403              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14404              """void fl_set_positioner_ystep(FL_OBJECT * ob, double value) 
14405              """) 
14406      fvalue = convert_to_double(value) 
14407      keep_elem_refs(pObject, value, fvalue) 
14408      _fl_set_positioner_ystep(pObject, fvalue) 
14409   
14410   
14411 -def fl_set_positioner_return(pObject, value): 
14412      """ fl_set_positioner_return(pObject, value) 
14413      """ 
14414   
14415      _fl_set_positioner_return = cfuncproto( 
14416              load_so_libforms(), "fl_set_positioner_return", 
14417              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
14418              """void fl_set_positioner_return(FL_OBJECT * ob, int value) 
14419              """) 
14420      ivalue = convert_to_int(value) 
14421      keep_elem_refs(pObject, value, ivalue) 
14422      _fl_set_positioner_return(pObject, ivalue) 
14423   
14424   
14425 -def fl_create_scrollbar(scrolltype, x, y, w, h, label): 
14426      """ fl_create_scrollbar(scrolltype, x, y, w, h, label) -> pObject 
14427      """ 
14428   
14429      _fl_create_scrollbar = cfuncproto( 
14430              load_so_libforms(), "fl_create_scrollbar", 
14431              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
14432              FL_Coord, STRING], 
14433              """FL_OBJECT * fl_create_scrollbar(int type, FL_Coord x, 
14434                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
14435              """) 
14436      check_admitted_listvalues(scrolltype, SCROLLTYPE_list) 
14437      iscrolltype = convert_to_int(scrolltype) 
14438      ix = convert_to_FL_Coord(x) 
14439      iy = convert_to_FL_Coord(y) 
14440      iw = convert_to_FL_Coord(w) 
14441      ih = convert_to_FL_Coord(h) 
14442      slabel = convert_to_string(label) 
14443      keep_elem_refs(scrolltype, x, y, w, h, label, iscrolltype, ix, iy, 
14444                     iw, ih, slabel) 
14445      retval = _fl_create_scrollbar(iscrolltype, ix, iy, iw, ih, slabel) 
14446      return retval 
14447   
14448   
14449 -def fl_add_scrollbar(scrolltype, x, y, w, h, label): 
14450      """ 
14451          fl_add_scrollbar(scrolltype, x, y, w, h, label) -> pObject 
14452   
14453          Adds a scrollbar to a form. 
14454   
14455          @param scrolltype : type of scrollbar 
14456          @param x : horizontal position (upper-left corner) 
14457          @param y : vertical position (upper-left corner) 
14458          @param w : width of the scrollbar 
14459          @param h : height of the scrollbar 
14460          @param label : label text of the scrollbar 
14461      """ 
14462   
14463      _fl_add_scrollbar = cfuncproto( 
14464              load_so_libforms(), "fl_add_scrollbar", 
14465              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
14466              FL_Coord, STRING], 
14467              """FL_OBJECT * fl_add_scrollbar(int type, FL_Coord x, FL_Coord y, 
14468                 FL_Coord w, FL_Coord h, const char * label) 
14469              """) 
14470      check_admitted_listvalues(scrolltype, SCROLLTYPE_list) 
14471      iscrolltype = convert_to_int(scrolltype) 
14472      ix = convert_to_FL_Coord(x) 
14473      iy = convert_to_FL_Coord(y) 
14474      iw = convert_to_FL_Coord(w) 
14475      ih = convert_to_FL_Coord(h) 
14476      slabel = convert_to_string(label) 
14477      keep_elem_refs(scrolltype, x, y, w, h, label, iscrolltype, ix, iy, 
14478                     iw, ih, slabel) 
14479      retval = _fl_add_scrollbar(iscrolltype, ix, iy, iw, ih, slabel) 
14480      return retval 
14481   
14482   
14483 -def fl_get_scrollbar_value(pObject): 
14484      """ 
14485          fl_get_scrollbar_value(pObject) -> value[float] 
14486   
14487          Returns the value of a scrollbar. 
14488   
14489          @param pObject : pointer to object 
14490      """ 
14491   
14492      _fl_get_scrollbar_value = cfuncproto( 
14493              load_so_libforms(), "fl_get_scrollbar_value", 
14494              cty.c_double, [cty.POINTER(FL_OBJECT)], 
14495              """double fl_get_scrollbar_value(FL_OBJECT * ob) 
14496              """) 
14497      keep_elem_refs(pObject) 
14498      retval = _fl_get_scrollbar_value(pObject) 
14499      return retval 
14500   
14501   
14502 -def fl_set_scrollbar_value(pObject, val): 
14503      """ 
14504          fl_set_scrollbar_value(pObject, val) 
14505   
14506          Sets the value of a scrollbar. 
14507   
14508          @param pObject : pointer to object 
14509          @param val : value of the scrollbar to be set 
14510      """ 
14511   
14512      _fl_set_scrollbar_value = cfuncproto( 
14513              load_so_libforms(), "fl_set_scrollbar_value", 
14514              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14515              """void fl_set_scrollbar_value(FL_OBJECT * ob, double val) 
14516              """) 
14517      fval = convert_to_double(val) 
14518      keep_elem_refs(pObject, val, fval) 
14519      _fl_set_scrollbar_value(pObject, fval) 
14520   
14521   
14522 -def fl_set_scrollbar_size(pObject, val): 
14523      """ fl_set_scrollbar_size(pObject, val) 
14524      """ 
14525   
14526      _fl_set_scrollbar_size = cfuncproto( 
14527              load_so_libforms(), "fl_set_scrollbar_size", 
14528              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14529              """void fl_set_scrollbar_size(FL_OBJECT * ob, double val) 
14530              """) 
14531      fval = convert_to_double(val) 
14532      keep_elem_refs(pObject, val, fval) 
14533      _fl_set_scrollbar_size(pObject, fval) 
14534   
14535   
14536 -def fl_set_scrollbar_increment(pObject, leftbtnval, midlbtnval): 
14537      """ 
14538          fl_set_scrollbar_increment(pObject, leftbtnval, midlbtnval) 
14539   
14540          Sets the size of the steps of a scrollbar jump. 
14541   
14542          @param pObject : pointer to object 
14543          @param leftbtnval : value to increment if the left mouse button is 
14544             pressed 
14545          @param midlbtnval : value to increment if the middle mouse button is 
14546             pressed 
14547      """ 
14548   
14549      _fl_set_scrollbar_increment = cfuncproto( 
14550              load_so_libforms(), "fl_set_scrollbar_increment", 
14551              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
14552              """void fl_set_scrollbar_increment(FL_OBJECT * ob, double l, 
14553                 double r) 
14554              """) 
14555      fleftbtnval = convert_to_double(leftbtnval) 
14556      fmidlbtnval = convert_to_double(midlbtnval) 
14557      keep_elem_refs(pObject, leftbtnval, midlbtnval, fleftbtnval, \ 
14558                     fmidlbtnval) 
14559      _fl_set_scrollbar_increment(pObject, fleftbtnval, fmidlbtnval) 
14560   
14561   
14562  #def fl_get_scrollbar_increment(pObject, leftbtnval, valmidlbtnval)       *API change* 
14563 -def fl_get_scrollbar_increment(pObject): 
14564      """ 
14565          fl_get_scrollbar_increment(pObject) -> leftbtnval[double], midlbtnval[double] 
14566   
14567          Returns the increment of size of a scrollbar for left and middle mouse 
14568          buttons. 
14569   
14570          @param pObject : pointer to object 
14571      """ 
14572   
14573      _fl_get_scrollbar_increment = cfuncproto( 
14574              load_so_libforms(), "fl_get_scrollbar_increment", 
14575              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
14576              cty.POINTER(cty.c_double)], 
14577              """void fl_get_scrollbar_increment(FL_OBJECT * ob, double * a, 
14578                 double * b) 
14579              """) 
14580      leftbtnval, pleftbtnval = make_double_and_pointer() 
14581      midlbtnval, pmidlbtnval = make_double_and_pointer() 
14582      keep_elem_refs(pObject, leftbtnval, midlbtnval, pleftbtnval, pmidlbtnval) 
14583      _fl_get_scrollbar_increment(pObject, pleftbtnval, pmidlbtnval) 
14584      return leftbtnval, midlbtnval 
14585   
14586   
14587 -def fl_set_scrollbar_bounds(pObject, minbound, maxbound): 
14588      """ 
14589          fl_set_scrollbar_bounds(pObject, minbound, maxbound) 
14590   
14591          Sets the bounds/limits of a scrollbar. 
14592   
14593          @param pObject : pointer to object 
14594          @param minbound : minimum bound of scrollbar 
14595          @param maxbound : maximum bound of scrollbar 
14596      """ 
14597   
14598      _fl_set_scrollbar_bounds = cfuncproto( 
14599              load_so_libforms(), "fl_set_scrollbar_bounds", 
14600              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
14601              """void fl_set_scrollbar_bounds(FL_OBJECT * ob, double b1, double b2) 
14602              """) 
14603      fminbound = convert_to_double(minbound) 
14604      fmaxbound = convert_to_double(maxbound) 
14605      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
14606      _fl_set_scrollbar_bounds(pObject, fminbound, fmaxbound) 
14607   
14608   
14609  #def fl_get_scrollbar_bounds(pObject, b1, b2)       *API change* 
14610 -def fl_get_scrollbar_bounds(pObject): 
14611      """ 
14612          fl_get_scrollbar_bounds(pObject) -> minbound, maxbound 
14613   
14614          Returns the bounds/limits of a scrollbar. 
14615   
14616          @param pObject : pointer to scrollbar object 
14617      """ 
14618   
14619      _fl_get_scrollbar_bounds = cfuncproto( 
14620              load_so_libforms(), "fl_get_scrollbar_bounds", 
14621              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
14622              cty.POINTER(cty.c_double)], 
14623              """void fl_get_scrollbar_bounds(FL_OBJECT * ob, double * b1, 
14624                 double * b2) 
14625              """) 
14626      minbound, pminbound = make_double_and_pointer() 
14627      maxbound, pmaxbound = make_double_and_pointer() 
14628      keep_elem_refs(pObject, minbound, pminbound, maxbound, pmaxbound) 
14629      _fl_get_scrollbar_bounds(pObject, pminbound, pmaxbound) 
14630      return minbound, maxbound 
14631   
14632   
14633 -def fl_set_scrollbar_return(pObject, returnnum): 
14634      """ 
14635          fl_set_scrollbar_return(pObject, returnnum) 
14636   
14637          Sets the type of return of a scrollbar. 
14638   
14639          @param pObject : pointer to scrollbar object 
14640          @param returnnum : value of return type 
14641      """ 
14642   
14643      _fl_set_scrollbar_return = cfuncproto( 
14644              load_so_libforms(), "fl_set_scrollbar_return", 
14645              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
14646              """void fl_set_scrollbar_return(FL_OBJECT * ob, int ret) 
14647              """) 
14648      check_admitted_listvalues(returnnum, RETURN_list) 
14649      ireturnnum = convert_to_int(returnnum) 
14650      keep_elem_refs(pObject, returnnum, ireturnnum) 
14651      _fl_set_scrollbar_return(pObject, ireturnnum) 
14652   
14653   
14654 -def fl_set_scrollbar_step(pObject, step): 
14655      """ fl_set_scrollbar_step(pObject, step) 
14656      """ 
14657   
14658      _fl_set_scrollbar_step = cfuncproto( 
14659              load_so_libforms(), "fl_set_scrollbar_step", 
14660              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14661              """void fl_set_scrollbar_step(FL_OBJECT * ob, double step) 
14662              """) 
14663      fstep = convert_to_double(step) 
14664      keep_elem_refs(pObject, step, fstep) 
14665      _fl_set_scrollbar_step(pObject, fstep) 
14666   
14667   
14668   
14669  ##################### 
14670  # forms.h (select.h) 
14671  ##################### 
14672   
14673  # Select object types 
14674   
14675 -def fl_create_select(selecttype, x, y, w, h, label): 
14676      """ fl_create_select(selecttype, x, y, w, h, label) -> pObject 
14677      """ 
14678   
14679      _fl_create_select = cfuncproto( 
14680              load_so_libforms(), "fl_create_select", 
14681              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
14682              FL_Coord, STRING], 
14683              """FL_OBJECT * fl_create_select(int p1, FL_Coord p2, FL_Coord p3, 
14684                 FL_Coord p4, FL_Coord p5, const char * p6) 
14685              """) 
14686      check_admitted_listvalues(selecttype, SELECTTYPE_list) 
14687      iselecttype = convert_to_int(selecttype) 
14688      ix = convert_to_FL_Coord(x) 
14689      iy = convert_to_FL_Coord(y) 
14690      iw = convert_to_FL_Coord(w) 
14691      ih = convert_to_FL_Coord(h) 
14692      slabel = convert_to_string(label) 
14693      keep_elem_refs(selecttype, x, y, w, h, label, iselecttype, ix, iy, 
14694                     iw, ih, slabel) 
14695      retval = _fl_create_select(iselecttype, ix, iy, iw, ih, slabel) 
14696      return retval 
14697   
14698   
14699 -def fl_add_select(selecttype, x, y, w, h, label): 
14700      """ fl_add_select(selecttype, x, y, w, h, label) -> pObject 
14701      """ 
14702   
14703      _fl_add_select = cfuncproto( 
14704              load_so_libforms(), "fl_add_select", 
14705              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
14706              FL_Coord, STRING], 
14707              """FL_OBJECT * fl_add_select(int p1, FL_Coord p2, FL_Coord p3, 
14708                 FL_Coord p4, FL_Coord p5, const char * p6) 
14709              """) 
14710      check_admitted_listvalues(selecttype, SELECTTYPE_list) 
14711      iselecttype = convert_to_int(selecttype) 
14712      ix = convert_to_FL_Coord(x) 
14713      iy = convert_to_FL_Coord(y) 
14714      iw = convert_to_FL_Coord(w) 
14715      ih = convert_to_FL_Coord(h) 
14716      slabel = convert_to_string(label) 
14717      keep_elem_refs(selecttype, x, y, w, h, label, iselecttype, ix, iy, 
14718                     iw, ih, slabel) 
14719      retval = _fl_add_select(iselecttype, ix, iy, iw, ih, slabel) 
14720      return retval 
14721   
14722   
14723 -def fl_clear_select(pObject): 
14724      """ fl_clear_select(pObject) 
14725   
14726          @param pObject : pointer to select object 
14727      """ 
14728   
14729      _fl_clear_select = cfuncproto( 
14730              load_so_libforms(), "fl_clear_select", 
14731              cty.c_int, [cty.POINTER(FL_OBJECT)], 
14732              """int fl_clear_select(FL_OBJECT * p1) 
14733              """) 
14734      keep_elem_refs(pObject) 
14735      _fl_clear_select(pObject) 
14736   
14737   
14738 -def fl_add_select_items(pObject, itemstr): 
14739      """ fl_add_select_items(pObject, itemstr) -> pPopupEntry 
14740      """ 
14741   
14742      _fl_add_select_items = cfuncproto( 
14743              load_so_libforms(), "fl_add_select_items", 
14744              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 
14745              """FL_POPUP_ENTRY * fl_add_select_items(FL_OBJECT * p1, 
14746                 const char * p2) 
14747              """) 
14748      sitemstr = convert_to_string(itemstr) 
14749      keep_elem_refs(pObject, itemstr, sitemstr) 
14750      retval = _fl_add_select_items(pObject, sitemstr) 
14751      return retval 
14752   
14753   
14754 -def fl_insert_select_items(pObject, pPopupEntry, itemstr): 
14755      """ fl_insert_select_items(pObject, pPopupEntry, itemstr) -> pPopupEntry 
14756      """ 
14757   
14758      _fl_insert_select_items = cfuncproto( 
14759              load_so_libforms(), "fl_insert_select_items", 
14760              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 
14761              cty.POINTER(FL_POPUP_ENTRY), STRING], 
14762              """FL_POPUP_ENTRY * fl_insert_select_items(FL_OBJECT * p1, 
14763                 FL_POPUP_ENTRY * p2, const char * p3) 
14764              """) 
14765      sitemstr = convert_to_string(itemstr) 
14766      keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 
14767      retval = _fl_insert_select_items(pObject, pPopupEntry, sitemstr) 
14768      return retval 
14769   
14770   
14771 -def fl_replace_select_item(pObject, pPopupEntry, itemstr): 
14772      """ fl_replace_select_item(pObject, pPopupEntry, itemstr) -> pPopupEntry 
14773      """ 
14774   
14775      _fl_replace_select_item = cfuncproto( 
14776              load_so_libforms(), "fl_replace_select_item", 
14777              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 
14778              cty.POINTER(FL_POPUP_ENTRY), STRING], 
14779              """FL_POPUP_ENTRY * fl_replace_select_item(FL_OBJECT * p1, 
14780                 FL_POPUP_ENTRY * p2, const char * p3) 
14781              """) 
14782      sitemstr = convert_to_string(itemstr) 
14783      keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 
14784      retval = _fl_replace_select_item(pObject, pPopupEntry, sitemstr) 
14785      return retval 
14786   
14787   
14788 -def fl_delete_select_item(pObject, pPopupEntry): 
14789      """ fl_delete_select_item(pObject, pPopupEntry) -> num. 
14790      """ 
14791   
14792      _fl_delete_select_item = cfuncproto( 
14793              load_so_libforms(), "fl_delete_select_item", 
14794              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP_ENTRY)], 
14795              """int fl_delete_select_item(FL_OBJECT * p1, FL_POPUP_ENTRY * p2) 
14796              """) 
14797      keep_elem_refs(pObject, pPopupEntry) 
14798      retval = _fl_delete_select_item(pObject, pPopupEntry) 
14799      return retval 
14800   
14801   
14802 -def fl_set_select_items(pObject, pPopupItem): 
14803      """ 
14804          fl_set_select_items(pObject, pPopupItem) -> num. 
14805   
14806          Repopulates a select object popup. 
14807   
14808          @param pObject : pointer to select object 
14809          @param pPopupItem : pointer to xfc.FL_POPUP_ITEM structure 
14810      """ 
14811   
14812      _fl_set_select_items = cfuncproto( 
14813              load_so_libforms(), "fl_set_select_items", 
14814              cty.c_long, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP_ITEM)], 
14815              """long int fl_set_select_items(FL_OBJECT * p1, 
14816                 FL_POPUP_ITEM * p2) 
14817              """) 
14818      #pPopupItem.callback = FL_POPUP_CB() 
14819      keep_elem_refs(pObject, pPopupItem) 
14820      retval = _fl_set_select_items(pObject, pPopupItem) 
14821      return retval 
14822   
14823   
14824 -def fl_get_select_popup(pObject): 
14825      """ fl_get_select_popup(pObject) -> pPopup 
14826      """ 
14827   
14828      _fl_get_select_popup = cfuncproto( 
14829              load_so_libforms(), "fl_get_select_popup", 
14830              cty.POINTER(FL_POPUP), [cty.POINTER(FL_OBJECT)], 
14831              """FL_POPUP * fl_get_select_popup(FL_OBJECT * p1) 
14832              """) 
14833      keep_elem_refs(pObject) 
14834      retval = _fl_get_select_popup(pObject) 
14835      return retval 
14836   
14837   
14838 -def fl_set_select_popup(pObject, pPopup): 
14839      """ fl_set_select_popup(pObject, pPopup) -> num. 
14840      """ 
14841   
14842      _fl_set_select_popup = cfuncproto( 
14843              load_so_libforms(), "fl_set_select_popup", 
14844              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP)], 
14845              """int fl_set_select_popup(FL_OBJECT * p1, FL_POPUP * p2) 
14846              """) 
14847      keep_elem_refs(pObject, pPopup) 
14848      retval = _fl_set_select_popup(pObject, pPopup) 
14849      return retval 
14850   
14851   
14852 -def fl_get_select_item(pObject): 
14853      """ fl_get_select_item(pObject) -> pPopupReturn 
14854      """ 
14855   
14856      _fl_get_select_item = cfuncproto( 
14857              load_so_libforms(), "fl_get_select_item", 
14858              cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_OBJECT)], 
14859              """FL_POPUP_RETURN * fl_get_select_item(FL_OBJECT * p1) 
14860              """) 
14861      keep_elem_refs(pObject) 
14862      retval = _fl_get_select_item(pObject) 
14863      return retval 
14864   
14865   
14866 -def fl_set_select_item(pObject, pPopupEntry): 
14867      """ fl_set_select_item(pObject, pPopupEntry) -> pPopupReturn 
14868      """ 
14869   
14870      _fl_set_select_item = cfuncproto( 
14871              load_so_libforms(), "fl_set_select_item", 
14872              cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_OBJECT), 
14873              cty.POINTER(FL_POPUP_ENTRY)], 
14874              """FL_POPUP_RETURN * fl_set_select_item(FL_OBJECT * p1, 
14875                 FL_POPUP_ENTRY * p2) 
14876              """) 
14877      keep_elem_refs(pObject, pPopupEntry) 
14878      retval = _fl_set_select_item(pObject, pPopupEntry) 
14879      return retval 
14880   
14881   
14882 -def fl_get_select_item_by_value(pObject, value): 
14883      """ fl_get_select_item_by_value(pObject, value) -> pPopupEntry 
14884      """ 
14885   
14886      _fl_get_select_item_by_value = cfuncproto( 
14887              load_so_libforms(), "fl_get_select_item_by_value", 
14888              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), cty.c_long], 
14889              """FL_POPUP_ENTRY * fl_get_select_item_by_value(FL_OBJECT * p1, 
14890                 long int p2) 
14891              """) 
14892      lvalue = convert_to_long(value) 
14893      keep_elem_refs(pObject, value, lvalue) 
14894      retval = _fl_get_select_item_by_value(pObject, lvalue) 
14895      return retval 
14896   
14897   
14898 -def fl_get_select_item_by_label(pObject, label): 
14899      """ fl_get_select_item_by_label(pObject, label) -> pPopupEntry 
14900      """ 
14901   
14902      _fl_get_select_item_by_label = cfuncproto( 
14903              load_so_libforms(), "fl_get_select_item_by_label", 
14904              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 
14905              """FL_POPUP_ENTRY * fl_get_select_item_by_label(FL_OBJECT * p1, 
14906                 const char * p2) 
14907              """) 
14908      slabel = convert_to_string(label) 
14909      keep_elem_refs(pObject, label, slabel) 
14910      retval = _fl_get_select_item_by_label(pObject, slabel) 
14911      return retval 
14912   
14913   
14914 -def fl_get_select_item_by_text(pObject, txtstr): 
14915      """ fl_get_select_item_by_text(pObject, txtstr) -> pPopupEntry 
14916      """ 
14917   
14918      _fl_get_select_item_by_text = cfuncproto( 
14919              load_so_libforms(), "fl_get_select_item_by_text", 
14920              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 
14921              """FL_POPUP_ENTRY * fl_get_select_item_by_text(FL_OBJECT * p1, 
14922                 const char * p2) 
14923              """) 
14924      stxtstr = convert_to_string(txtstr) 
14925      keep_elem_refs(pObject, txtstr, stxtstr) 
14926      retval = _fl_get_select_item_by_text(pObject, stxtstr) 
14927      return retval 
14928   
14929   
14930 -def fl_get_select_text_color(pObject): 
14931      """ fl_get_select_text_color(pObject) -> color 
14932      """ 
14933   
14934      _fl_get_select_text_color = cfuncproto( 
14935              load_so_libforms(), "fl_get_select_text_color", 
14936              FL_COLOR, [cty.POINTER(FL_OBJECT)], 
14937              """FL_COLOR fl_get_select_text_color(FL_OBJECT * p1) 
14938              """) 
14939      keep_elem_refs(pObject) 
14940      retval = _fl_get_select_text_color(pObject) 
14941      return retval 
14942   
14943   
14944 -def fl_set_select_text_color(pObject, colr): 
14945      """ fl_set_select_text_color(pObject, colr) -> color 
14946      """ 
14947   
14948      _fl_set_select_text_color = cfuncproto( 
14949              load_so_libforms(), "fl_set_select_text_color", 
14950              FL_COLOR, [cty.POINTER(FL_OBJECT), FL_COLOR], 
14951              """FL_COLOR fl_set_select_text_color(FL_OBJECT * p1, FL_COLOR p2) 
14952              """) 
14953      ulcolr = convert_to_FL_COLOR(colr) 
14954      keep_elem_refs(pObject, colr, ulcolr) 
14955      retval = _fl_set_select_text_color(pObject, ulcolr) 
14956      return retval 
14957   
14958   
14959  #def fl_get_select_text_font(pObject, p2, p3)       *API change* 
14960 -def fl_get_select_text_font(pObject): 
14961      """ fl_get_select_text_font(pObject) -> num, num1, num2 
14962      """ 
14963   
14964      _fl_get_select_text_font = cfuncproto( 
14965              load_so_libforms(), "fl_get_select_text_font", 
14966              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
14967              cty.POINTER(cty.c_int)], 
14968              """int fl_get_select_text_font(FL_OBJECT * p1, int * p2, int * p3) 
14969              """) 
14970      num1, pnum1 = make_int_and_pointer() 
14971      num2, pnum2 = make_int_and_pointer() 
14972      keep_elem_refs(pObject, num1, num2, pnum1, pnum2) 
14973      retval = _fl_get_select_text_font(pObject, pnum2, pnum2) 
14974      return retval, num1, num2 
14975   
14976   
14977 -def fl_set_select_text_font(pObject, p2, p3): 
14978      """ fl_set_select_text_font(pObject, p2, p3) -> font num. 
14979      """ 
14980   
14981      _fl_set_select_text_font = cfuncproto( 
14982              load_so_libforms(), "fl_set_select_text_font", 
14983              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
14984              """int fl_set_select_text_font(FL_OBJECT * p1, int p2, int p3) 
14985              """) 
14986      ip2 = convert_to_int(p2) 
14987      ip3 = convert_to_int(p3) 
14988      keep_elem_refs(pObject, p2, p3, ip2, ip3) 
14989      retval = _fl_set_select_text_font(pObject, ip2, ip3) 
14990      return retval 
14991   
14992   
14993 -def fl_get_select_text_align(pObject): 
14994      """ fl_get_select_text_align(pObject) -> num. 
14995      """ 
14996   
14997      _fl_get_select_text_align = cfuncproto( 
14998              load_so_libforms(), "fl_get_select_text_align", 
14999              cty.c_int, [cty.POINTER(FL_OBJECT)], 
15000              """int fl_get_select_text_align(FL_OBJECT * p1) 
15001              """) 
15002      keep_elem_refs(pObject) 
15003      retval = _fl_get_select_text_align(pObject) 
15004      return retval 
15005   
15006   
15007 -def fl_set_select_text_align(pObject, p2): 
15008      """ fl_set_select_text_align(pObject, p2) -> num. 
15009      """ 
15010   
15011      _fl_set_select_text_align = cfuncproto( 
15012              load_so_libforms(), "fl_set_select_text_align", 
15013              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
15014              """int fl_set_select_text_align(FL_OBJECT * p1, int p2) 
15015              """) 
15016      ip2 = convert_to_int(p2) 
15017      keep_elem_refs(pObject, p2, ip2) 
15018      retval = _fl_set_select_text_align(pObject, ip2) 
15019      return retval 
15020   
15021   
15022 -def fl_set_select_policy(pObject, num): 
15023      """ fl_set_select_policy(pObject, num) -> num. 
15024      """ 
15025   
15026      _fl_set_select_policy = cfuncproto( 
15027              load_so_libforms(), "fl_set_select_policy", 
15028              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
15029              """int fl_set_select_policy(FL_OBJECT * p1, int p2) 
15030              """) 
15031      inum = convert_to_int(num) 
15032      keep_elem_refs(pObject, num, inum) 
15033      retval = _fl_set_select_policy(pObject, inum) 
15034      return retval 
15035   
15036   
15037   
15038  ####################### 
15039  # forms.h (slider.h) 
15040  # Object Class: Slider 
15041  ####################### 
15042   
15043  # Routines 
15044   
15045 -def fl_create_slider(slidertype, x, y, w, h, label): 
15046      """ fl_create_slider(slidertype, x, y, w, h, label) -> pObject 
15047      """ 
15048   
15049      _fl_create_slider = cfuncproto( 
15050              load_so_libforms(), "fl_create_slider", 
15051              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15052              FL_Coord, STRING], 
15053              """FL_OBJECT * fl_create_slider(int type, FL_Coord x, FL_Coord y, 
15054                 FL_Coord w, FL_Coord h, const char * label) 
15055              """) 
15056      check_admitted_listvalues(slidertype, SLIDERTYPE_list) 
15057      islidertype = convert_to_int(slidertype) 
15058      ix = convert_to_FL_Coord(x) 
15059      iy = convert_to_FL_Coord(y) 
15060      iw = convert_to_FL_Coord(w) 
15061      ih = convert_to_FL_Coord(h) 
15062      slabel = convert_to_string(label) 
15063      keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 
15064                     iw, ih, slabel) 
15065      retval = _fl_create_slider(islidertype, ix, iy, iw, ih, slabel) 
15066      return retval 
15067   
15068   
15069 -def fl_add_slider(slidertype, x, y, w, h, label): 
15070      """ 
15071          fl_add_slider(slidertype, x, y, w, h, label) -> pObject 
15072   
15073          Adds a slider to a form. No value is displayed. 
15074   
15075          @param slidertype : type of the slider 
15076          @param x : horizontal position (upper-left corner) 
15077          @param y : vertical position (upper-left corner) 
15078          @param w : width of the slider 
15079          @param h : height of the slider 
15080          @param label : label of the slider (placed below it by default) 
15081      """ 
15082   
15083      _fl_add_slider = cfuncproto( 
15084              load_so_libforms(), "fl_add_slider", 
15085              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15086              FL_Coord, STRING], 
15087              """FL_OBJECT * fl_add_slider(int type, FL_Coord x, FL_Coord y, 
15088                 FL_Coord w, FL_Coord h, const char * label) 
15089              """) 
15090      check_admitted_listvalues(slidertype, SLIDERTYPE_list) 
15091      islidertype = convert_to_int(slidertype) 
15092      ix = convert_to_FL_Coord(x) 
15093      iy = convert_to_FL_Coord(y) 
15094      iw = convert_to_FL_Coord(w) 
15095      ih = convert_to_FL_Coord(h) 
15096      slabel = convert_to_string(label) 
15097      keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 
15098                     iw, ih, slabel) 
15099      retval = _fl_add_slider(islidertype, ix, iy, iw, ih, slabel) 
15100      return retval 
15101   
15102   
15103 -def fl_create_valslider(slidertype, x, y, w, h, label): 
15104      """ fl_create_valslider(slidertype, x, y, w, h, label) -> pObject 
15105      """ 
15106   
15107      _fl_create_valslider = cfuncproto( 
15108              load_so_libforms(), "fl_create_valslider", 
15109              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15110              FL_Coord, STRING], 
15111              """FL_OBJECT * fl_create_valslider(int type, FL_Coord x, 
15112                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
15113              """) 
15114      check_admitted_listvalues(slidertype, SLIDERTYPE_list) 
15115      islidertype = convert_to_int(slidertype) 
15116      ix = convert_to_FL_Coord(x) 
15117      iy = convert_to_FL_Coord(y) 
15118      iw = convert_to_FL_Coord(w) 
15119      ih = convert_to_FL_Coord(h) 
15120      slabel = convert_to_string(label) 
15121      keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 
15122                     iw, ih, slabel) 
15123      retval = _fl_create_valslider(islidertype, ix, iy, iw, ih, slabel) 
15124      return retval 
15125   
15126   
15127 -def fl_add_valslider(slidertype, x, y, w, h, label): 
15128      """ 
15129          fl_add_valslider(slidertype, x, y, w, h, label) -> pObject 
15130   
15131          Adds a slider to a form. Its value is displayed above or to the 
15132          left of the slider. 
15133   
15134          @param slidertype : type of the slider 
15135          @param x : horizontal position (upper-left corner) 
15136          @param y : vertical position (upper-left corner) 
15137          @param w : width of the slider 
15138          @param h : height of the slider 
15139          @param label : label of the slider (placed below it by default) 
15140      """ 
15141   
15142      _fl_add_valslider = cfuncproto( 
15143              load_so_libforms(), "fl_add_valslider", 
15144              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15145              FL_Coord, STRING], 
15146              """FL_OBJECT * fl_add_valslider(int type, FL_Coord x, FL_Coord y, 
15147                 FL_Coord w, FL_Coord h, const char * label) 
15148              """) 
15149      check_admitted_listvalues(slidertype, SLIDERTYPE_list) 
15150      islidertype = convert_to_int(slidertype) 
15151      ix = convert_to_FL_Coord(x) 
15152      iy = convert_to_FL_Coord(y) 
15153      iw = convert_to_FL_Coord(w) 
15154      ih = convert_to_FL_Coord(h) 
15155      slabel = convert_to_string(label) 
15156      keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 
15157                     iw, ih, slabel) 
15158      retval = _fl_add_valslider(islidertype, ix, iy, iw, ih, slabel) 
15159      return retval 
15160   
15161   
15162 -def fl_set_slider_value(pObject, val): 
15163      """ 
15164          fl_set_slider_value(pObject, val) 
15165   
15166          Changes the value of a slider. 
15167   
15168          @param pObject : pointer to object 
15169          @param val : new value of slider 
15170      """ 
15171   
15172      _fl_set_slider_value = cfuncproto( 
15173              load_so_libforms(), "fl_set_slider_value", 
15174              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
15175              """void fl_set_slider_value(FL_OBJECT * ob, double val) 
15176              """) 
15177      fval = convert_to_double(val) 
15178      keep_elem_refs(pObject, val, fval) 
15179      _fl_set_slider_value(pObject, fval) 
15180   
15181   
15182 -def fl_get_slider_value(pObject): 
15183      """ 
15184          fl_get_slider_value(pObject) -> value[float] 
15185   
15186          Returns value of a slider. 
15187   
15188          @param pObject : pointer to object 
15189      """ 
15190   
15191      _fl_get_slider_value = cfuncproto( 
15192              load_so_libforms(), "fl_get_slider_value", 
15193              cty.c_double, [cty.POINTER(FL_OBJECT)], 
15194              """double fl_get_slider_value(FL_OBJECT * ob) 
15195              """) 
15196      keep_elem_refs(pObject) 
15197      retval = _fl_get_slider_value(pObject) 
15198      return retval 
15199   
15200   
15201 -def fl_set_slider_bounds(pObject, minbound, maxbound): 
15202      """ 
15203          fl_set_slider_bounds(pObject, minbound, maxbound) 
15204   
15205          Sets bounds/limits of a slider. 
15206   
15207          @param pObject : pointer to object 
15208          @param minbound : minimum bound of slider 
15209          @param maxbound : maximum bound of slider 
15210      """ 
15211   
15212      _fl_set_slider_bounds = cfuncproto( 
15213              load_so_libforms(), "fl_set_slider_bounds", 
15214              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
15215              """void fl_set_slider_bounds(FL_OBJECT * ob, double min, 
15216                 double max) 
15217              """) 
15218      fminbound = convert_to_double(minbound) 
15219      fmaxbound = convert_to_double(maxbound) 
15220      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
15221      _fl_set_slider_bounds(pObject, fminbound, fmaxbound) 
15222   
15223   
15224  #def fl_get_slider_bounds(pObject, minbound, maxbound)       *API change* 
15225 -def fl_get_slider_bounds(pObject): 
15226      """ 
15227          fl_get_slider_bounds(pObject) -> minbound[float], maxbound[float] 
15228   
15229          Returns bounds/limits of a slider. 
15230   
15231          @param pObject : pointer to object 
15232      """ 
15233   
15234      _fl_get_slider_bounds = cfuncproto( 
15235              load_so_libforms(), "fl_get_slider_bounds", 
15236              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
15237              cty.POINTER(cty.c_double)], 
15238              """void fl_get_slider_bounds(FL_OBJECT * ob, double * min, 
15239                 double * max) 
15240              """) 
15241      minbound, pminbound = make_double_and_pointer() 
15242      maxbound, pmaxbound = make_double_and_pointer() 
15243      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
15244      _fl_get_slider_bounds(pObject, pminbound, pmaxbound) 
15245      return minbound, maxbound 
15246   
15247   
15248 -def fl_set_slider_return(pObject, returnnum): 
15249      """ 
15250          fl_set_slider_return(pObject, returnnum) 
15251   
15252          Sets the return value of a slider. 
15253   
15254          @param pObject : pointer to object 
15255          @param returnnum : value of return (e.g. xfc.FL_RETURN_NONE, etc..) 
15256      """ 
15257   
15258      _fl_set_slider_return = cfuncproto( 
15259              load_so_libforms(), "fl_set_slider_return", 
15260              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
15261              """void fl_set_slider_return(FL_OBJECT * ob, int value) 
15262              """) 
15263      check_admitted_listvalues(returnnum, RETURN_list) 
15264      ireturnnum = convert_to_int(returnnum) 
15265      keep_elem_refs(pObject, returnnum, ireturnnum) 
15266      _fl_set_slider_return(pObject, ireturnnum) 
15267   
15268   
15269 -def fl_set_slider_step(pObject, value): 
15270      """ fl_set_slider_step(pObject, value) 
15271      """ 
15272   
15273      _fl_set_slider_step = cfuncproto( 
15274              load_so_libforms(), "fl_set_slider_step", 
15275              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
15276              """void fl_set_slider_step(FL_OBJECT * ob, double value) 
15277              """) 
15278      fvalue = convert_to_double(value) 
15279      keep_elem_refs(pObject, value, fvalue) 
15280      _fl_set_slider_step(pObject, fvalue) 
15281   
15282   
15283 -def fl_set_slider_increment(pObject, leftbtnval, midlbtnval): 
15284      """ fl_set_slider_increment(pObject, leftbtnval, midlbtnval) 
15285      """ 
15286   
15287      _fl_set_slider_increment = cfuncproto( 
15288              load_so_libforms(), "fl_set_slider_increment", 
15289              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
15290              """void fl_set_slider_increment(FL_OBJECT * ob, double l, 
15291                 double r) 
15292              """) 
15293      fleftbtnval = convert_to_double(leftbtnval) 
15294      fmidlbtnval = convert_to_double(midlbtnval) 
15295      keep_elem_refs(pObject, leftbtnval, midlbtnval, fleftbtnval, fmidlbtnval) 
15296      _fl_set_slider_increment(pObject, fleftbtnval, fmidlbtnval) 
15297   
15298   
15299  #def fl_get_slider_increment(pObject, leftbtnval, midlbtnval)       *API change* 
15300 -def fl_get_slider_increment(pObject): 
15301      """ fl_get_slider_increment(pObject) -> leftbtnval, midlbtnval 
15302      """ 
15303   
15304      _fl_get_slider_increment = cfuncproto( 
15305              load_so_libforms(), "fl_get_slider_increment", 
15306              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
15307              cty.POINTER(cty.c_double)], \ 
15308              """void fl_get_slider_increment(FL_OBJECT * ob, double * l, 
15309                 double * r) 
15310              """) 
15311      leftbtnval, pleftbtnval = make_double_and_pointer() 
15312      midlbtnval, pmidlbtnval = make_double_and_pointer() 
15313      keep_elem_refs(pObject, leftbtnval, midlbtnval, pleftbtnval, pmidlbtnval) 
15314      _fl_get_slider_increment(pObject, pleftbtnval, pmidlbtnval) 
15315      return leftbtnval, midlbtnval 
15316   
15317   
15318 -def fl_set_slider_size(pObject, size): 
15319      """ 
15320          fl_set_slider_size(pObject, size) 
15321   
15322          Sets the size of a slider. 
15323   
15324          @param pObject : pointer to object 
15325          @param size : value of size of the slider 
15326      """ 
15327   
15328      _fl_set_slider_size = cfuncproto( 
15329              load_so_libforms(), "fl_set_slider_size", 
15330              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
15331              """void fl_set_slider_size(FL_OBJECT * ob, double size) 
15332              """) 
15333      fsize = convert_to_double(size) 
15334      keep_elem_refs(pObject, size, fsize) 
15335      _fl_set_slider_size(pObject, fsize) 
15336   
15337   
15338 -def fl_set_slider_precision(pObject, precnum): 
15339      """ 
15340          fl_set_slider_precision(pObject, precnum) 
15341   
15342          Sets precision with which value a valslider is shown. 
15343   
15344          @param pObject : pointer to object 
15345          @param precnum : precision of shown value 
15346      """ 
15347   
15348      _fl_set_slider_precision = cfuncproto( 
15349              load_so_libforms(), "fl_set_slider_precision", 
15350              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
15351              """void fl_set_slider_precision(FL_OBJECT * ob, int prec) 
15352              """) 
15353      iprecnum = convert_to_int(precnum) 
15354      keep_elem_refs(pObject, precnum, iprecnum) 
15355      _fl_set_slider_precision(pObject, iprecnum) 
15356   
15357   
15358 -def fl_set_slider_filter(pObject, py_ValFilter): 
15359      """ 
15360          fl_set_slider_filter(pObject, py_ValFilter) 
15361   
15362          Overrides the default (slider value shown in floating point format) 
15363          by registering a filter function. 
15364   
15365          @param pObject : pointer to oject 
15366          @param py_ValFilter : python function, fn(pObject, valfloat, 
15367             intprecis) -> string 
15368      """ 
15369   
15370      _fl_set_slider_filter = cfuncproto( 
15371              load_so_libforms(), "fl_set_slider_filter", 
15372              None, [cty.POINTER(FL_OBJECT), FL_VAL_FILTER], 
15373              """void fl_set_slider_filter(FL_OBJECT * ob, FL_VAL_FILTER filter) 
15374              """) 
15375      c_ValFilter = FL_VAL_FILTER(py_ValFilter) 
15376      keep_cfunc_refs(c_ValFilter, py_ValFilter) 
15377      keep_elem_refs(pObject) 
15378      _fl_set_slider_filter(pObject, c_ValFilter) 
15379   
15380   
15381 -def fl_create_spinner(spinnertype, x, y, w, h, label): 
15382      """ fl_create_spinner(spinnertype, x, y, w, h, label) -> pObject 
15383      """ 
15384   
15385      _fl_create_spinner = cfuncproto( 
15386              load_so_libforms(), "fl_create_spinner", 
15387              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15388              FL_Coord, STRING], 
15389              """FL_OBJECT * fl_create_spinner(int type, FL_Coord x, FL_Coord y, 
15390                 FL_Coord w, FL_Coord h, const char * label) 
15391              """) 
15392      check_admitted_listvalues(spinnertype, SPINNERTYPE_list) 
15393      ispinnertype = convert_to_int(spinnertype) 
15394      ix = convert_to_FL_Coord(x) 
15395      iy = convert_to_FL_Coord(y) 
15396      iw = convert_to_FL_Coord(w) 
15397      ih = convert_to_FL_Coord(h) 
15398      slabel = convert_to_string(label) 
15399      keep_elem_refs(spinnertype, x, y, w, h, label, ispinnertype, ix, iy, 
15400                     iw, ih, slabel) 
15401      retval = _fl_create_spinner(ispinnertype, ix, iy, iw, ih, slabel) 
15402      return retval 
15403   
15404   
15405 -def fl_add_spinner(spinnertype, x, y, w, h, label): 
15406      """ fl_add_spinner(spinnertype, x, y, w, h, label) -> pObject 
15407      """ 
15408   
15409      _fl_add_spinner = cfuncproto( 
15410              load_so_libforms(), "fl_add_spinner", 
15411              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15412              FL_Coord, STRING], 
15413              """FL_OBJECT * fl_add_spinner(int type, FL_Coord x, FL_Coord y, 
15414              FL_Coord w, FL_Coord h, const char * label) 
15415              """) 
15416      check_admitted_listvalues(spinnertype, SPINNERTYPE_list) 
15417      ispinnertype = convert_to_int(spinnertype) 
15418      ix = convert_to_FL_Coord(x) 
15419      iy = convert_to_FL_Coord(y) 
15420      iw = convert_to_FL_Coord(w) 
15421      ih = convert_to_FL_Coord(h) 
15422      slabel = convert_to_string(label) 
15423      keep_elem_refs(spinnertype, x, y, w, h, label, ispinnertype, ix, iy, 
15424                     iw, ih, slabel) 
15425      retval = _fl_add_spinner(ispinnertype, ix, iy, iw, ih, slabel) 
15426      return retval 
15427   
15428   
15429 -def fl_get_spinner_value(pObject): 
15430      """ fl_get_spinner_value(pObject) -> floatval 
15431      """ 
15432   
15433      _fl_get_spinner_value = cfuncproto( 
15434              load_so_libforms(), "fl_get_spinner_value", 
15435              cty.c_double, [cty.POINTER(FL_OBJECT)], 
15436              """double fl_get_spinner_value(FL_OBJECT * obj) 
15437              """) 
15438      keep_elem_refs(pObject) 
15439      retval = _fl_get_spinner_value(pObject) 
15440      return retval 
15441   
15442   
15443 -def fl_set_spinner_value(pObject, val): 
15444      """ fl_set_spinner_value(pObject, val) -> num. 
15445      """ 
15446   
15447      _fl_set_spinner_value = cfuncproto( 
15448              load_so_libforms(), "fl_set_spinner_value", 
15449              cty.c_double, [cty.POINTER(FL_OBJECT), cty.c_double], 
15450              """double fl_set_spinner_value(FL_OBJECT * obj, double val) 
15451              """) 
15452      fval = convert_to_double(val) 
15453      keep_elem_refs(pObject, val, fval) 
15454      _fl_set_spinner_value(pObject, fval) 
15455   
15456   
15457 -def fl_set_spinner_bounds(pObject, minbound, maxbound): 
15458      """ fl_set_spinner_bounds(pObject, minbound, maxbound) 
15459      """ 
15460   
15461      _fl_set_spinner_bounds = cfuncproto( 
15462              load_so_libforms(), "fl_set_spinner_bounds", 
15463              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
15464              """void fl_set_spinner_bounds(FL_OBJECT * obj, double min, 
15465                 double max) 
15466              """) 
15467      fminbound = convert_to_double(minbound) 
15468      fmaxbound = convert_to_double(maxbound) 
15469      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
15470      _fl_set_spinner_bounds(pObject, fminbound, fmaxbound) 
15471   
15472   
15473  #def fl_get_spinner_bounds(pObject, minbound, maxbound):       *API change* 
15474 -def fl_get_spinner_bounds(pObject): 
15475      """ fl_get_spinner_bounds(pObject) -> minbound, maxbound 
15476      """ 
15477   
15478      _fl_get_spinner_bounds = cfuncproto( 
15479              load_so_libforms(), "fl_get_spinner_bounds", 
15480              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
15481              cty.POINTER(cty.c_double)], \ 
15482              """void fl_get_spinner_bounds(FL_OBJECT * obj, double * min, 
15483                 double * max) 
15484              """) 
15485      minbound, pminbound = make_double_and_pointer() 
15486      maxbound, pmaxbound = make_double_and_pointer() 
15487      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
15488      _fl_get_spinner_bounds(pObject, pminbound, pmaxbound) 
15489      return minbound, maxbound 
15490   
15491   
15492 -def fl_set_spinner_step(pObject, step): 
15493      """ fl_set_spinner_step(pObject, step) 
15494      """ 
15495   
15496      _fl_set_spinner_step = cfuncproto( 
15497              load_so_libforms(), "fl_set_spinner_step", 
15498              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
15499              """void fl_set_spinner_step(FL_OBJECT * obj, double step) 
15500              """) 
15501      fstep = convert_to_double(step) 
15502      keep_elem_refs(pObject, step, fstep) 
15503      _fl_set_spinner_step(pObject, fstep) 
15504   
15505   
15506 -def fl_get_spinner_step(pObject): 
15507      """ fl_get_spinner_step(pObject) -> num. 
15508      """ 
15509   
15510      _fl_get_spinner_step = cfuncproto( 
15511              load_so_libforms(), "fl_get_spinner_step", 
15512              cty.c_double, [cty.POINTER(FL_OBJECT)], 
15513              """double fl_get_spinner_step(FL_OBJECT * obj) 
15514              """) 
15515      keep_elem_refs(pObject) 
15516      retval = _fl_get_spinner_step(pObject) 
15517      return retval 
15518   
15519   
15520 -def fl_set_spinner_precision(pObject, precnum): 
15521      """ fl_set_spinner_precision(pObject, precnum) 
15522      """ 
15523   
15524      _fl_set_spinner_precision = cfuncproto( 
15525              load_so_libforms(), "fl_set_spinner_precision", 
15526              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
15527              """void fl_set_spinner_precision(FL_OBJECT * obj, int prec) 
15528              """) 
15529      iprecnum = convert_to_int(precnum) 
15530      keep_elem_refs(pObject, precnum, iprecnum) 
15531      _fl_set_spinner_precision(pObject, iprecnum) 
15532   
15533   
15534 -def fl_get_spinner_precision(pObject): 
15535      """ fl_get_spinner_precision(pObject) -> num. 
15536      """ 
15537   
15538      _fl_get_spinner_precision = cfuncproto( 
15539              load_so_libforms(), "fl_get_spinner_precision", 
15540              cty.c_int, [cty.POINTER(FL_OBJECT)], 
15541              """int fl_get_spinner_precision(FL_OBJECT * obj) 
15542              """) 
15543      keep_elem_refs(pObject) 
15544      retval = _fl_get_spinner_precision(pObject) 
15545      return retval 
15546   
15547   
15548 -def fl_get_spinner_input(pObject): 
15549      """ fl_get_spinner_input(pObject) -> pObject 
15550      """ 
15551   
15552      _fl_get_spinner_input = cfuncproto( 
15553              load_so_libforms(), "fl_get_spinner_input", 
15554              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], 
15555              """FL_OBJECT * fl_get_spinner_input(FL_OBJECT * obj) 
15556              """) 
15557      keep_elem_refs(pObject) 
15558      retval = _fl_get_spinner_input(pObject) 
15559      return retval 
15560   
15561   
15562 -def fl_get_spinner_up_button(pObject): 
15563      """ fl_get_spinner_up_button(pObject) -> pObject 
15564      """ 
15565   
15566      _fl_get_spinner_up_button = cfuncproto( 
15567              load_so_libforms(), "fl_get_spinner_up_button", 
15568              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], 
15569              """FL_OBJECT * fl_get_spinner_up_button(FL_OBJECT * obj) 
15570              """) 
15571      keep_elem_refs(pObject) 
15572      retval = _fl_get_spinner_up_button(pObject) 
15573      return retval 
15574   
15575   
15576 -def fl_get_spinner_down_button(pObject): 
15577      """ fl_get_spinner_down_button(pObject) -> pObject 
15578      """ 
15579   
15580      _fl_get_spinner_down_button = cfuncproto( 
15581              load_so_libforms(), "fl_get_spinner_down_button", 
15582              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], 
15583              """FL_OBJECT * fl_get_spinner_down_button(FL_OBJECT * obj) 
15584              """) 
15585      keep_elem_refs(pObject) 
15586      retval = _fl_get_spinner_down_button(pObject) 
15587      return retval 
15588   
15589   
15590   
15591  ######################## 
15592  # forms.h (tabfolder.h) 
15593  ######################## 
15594   
15595 -def fl_create_tabfolder(foldertype, x, y, w, h, label): 
15596      """ fl_create_tabfolder(foldertype, x, y, w, h, label) -> pObject 
15597      """ 
15598   
15599      _fl_create_tabfolder = cfuncproto( 
15600              load_so_libforms(), "fl_create_tabfolder", 
15601              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15602              FL_Coord, STRING], 
15603              """FL_OBJECT * fl_create_tabfolder(int type, FL_Coord x, 
15604                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
15605              """) 
15606      check_admitted_listvalues(foldertype, TABFOLDERTYPE_list) 
15607      ifoldertype = convert_to_int(foldertype) 
15608      ix = convert_to_FL_Coord(x) 
15609      iy = convert_to_FL_Coord(y) 
15610      iw = convert_to_FL_Coord(w) 
15611      ih = convert_to_FL_Coord(h) 
15612      slabel = convert_to_string(label) 
15613      keep_elem_refs(foldertype, x, y, w, h, label, ifoldertype, ix, iy, 
15614                     iw, ih, slabel) 
15615      retval = _fl_create_tabfolder(ifoldertype, ix, iy, iw, ih, slabel) 
15616      return retval 
15617   
15618   
15619 -def fl_add_tabfolder(foldertype, x, y, w, h, label): 
15620      """ fl_add_tabfolder(foldertype, x, y, w, h, label) -> pObject 
15621      """ 
15622   
15623      _fl_add_tabfolder = cfuncproto( 
15624              load_so_libforms(), "fl_add_tabfolder", 
15625              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15626              FL_Coord, STRING], 
15627              """FL_OBJECT * fl_add_tabfolder(int type, FL_Coord x, FL_Coord y, 
15628                 FL_Coord w, FL_Coord h, const char * label) 
15629              """) 
15630      check_admitted_listvalues(foldertype, TABFOLDERTYPE_list) 
15631      ifoldertype = convert_to_int(foldertype) 
15632      ix = convert_to_FL_Coord(x) 
15633      iy = convert_to_FL_Coord(y) 
15634      iw = convert_to_FL_Coord(w) 
15635      ih = convert_to_FL_Coord(h) 
15636      slabel = convert_to_string(label) 
15637      keep_elem_refs(foldertype, x, y, w, h, label, ifoldertype, ix, iy, 
15638                     iw, ih, slabel) 
15639      retval = _fl_add_tabfolder(ifoldertype, ix, iy, iw, ih, slabel) 
15640      return retval 
15641   
15642   
15643 -def fl_addto_tabfolder(pObject, title, pForm): 
15644      """ fl_addto_tabfolder(pObject, title, pForm) -> pObject 
15645      """ 
15646   
15647      _fl_addto_tabfolder = cfuncproto( 
15648              load_so_libforms(), "fl_addto_tabfolder", 
15649              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT), STRING, 
15650              cty.POINTER(FL_FORM)], 
15651              """FL_OBJECT * fl_addto_tabfolder(FL_OBJECT * ob, 
15652                 const char * title, FL_FORM * form) 
15653              """) 
15654      stitle = convert_to_string(title) 
15655      keep_elem_refs(pObject, title, pForm, stitle) 
15656      retval = _fl_addto_tabfolder(pObject, stitle, pForm) 
15657      return retval 
15658   
15659   
15660 -def fl_get_tabfolder_folder_bynumber(pObject, num): 
15661      """ fl_get_tabfolder_folder_bynumber(pObject, num) -> pForm 
15662      """ 
15663   
15664      _fl_get_tabfolder_folder_bynumber = cfuncproto( 
15665              load_so_libforms(), "fl_get_tabfolder_folder_bynumber", 
15666              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 
15667              """FL_FORM * fl_get_tabfolder_folder_bynumber(FL_OBJECT * ob, 
15668                 int num) 
15669              """) 
15670      inum = convert_to_int(num) 
15671      keep_elem_refs(pObject, num, inum) 
15672      retval = _fl_get_tabfolder_folder_bynumber(pObject, inum) 
15673      return retval 
15674   
15675   
15676 -def fl_get_tabfolder_folder_byname(pObject, name): 
15677      """ fl_get_tabfolder_folder_byname(pObject, name) -> pForm 
15678      """ 
15679   
15680      _fl_get_tabfolder_folder_byname = cfuncproto( 
15681              load_so_libforms(), "fl_get_tabfolder_folder_byname", 
15682              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), STRING], 
15683              """FL_FORM * fl_get_tabfolder_folder_byname(FL_OBJECT * ob, 
15684                 const char * name) 
15685              """) 
15686      sname = convert_to_string(name) 
15687      keep_elem_refs(pObject, name, sname) 
15688      retval = _fl_get_tabfolder_folder_byname(pObject, sname) 
15689      return retval 
15690   
15691   
15692 -def fl_delete_folder(pObject, pForm): 
15693      """ fl_delete_folder(pObject, pForm) 
15694      """ 
15695   
15696      _fl_delete_folder = cfuncproto( 
15697              load_so_libforms(), "fl_delete_folder", 
15698              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 
15699              """void fl_delete_folder(FL_OBJECT * ob, FL_FORM * form) 
15700              """) 
15701      keep_elem_refs(pObject, pForm) 
15702      _fl_delete_folder(pObject, pForm) 
15703   
15704   
15705 -def fl_delete_folder_bynumber(pObject, num): 
15706      """ fl_delete_folder_bynumber(pObject, num) 
15707      """ 
15708   
15709      _fl_delete_folder_bynumber = cfuncproto( 
15710              load_so_libforms(), "fl_delete_folder_bynumber", 
15711              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
15712              """void fl_delete_folder_bynumber(FL_OBJECT * ob, int num) 
15713              """) 
15714      inum = convert_to_int(num) 
15715      keep_elem_refs(pObject, num, inum) 
15716      _fl_delete_folder_bynumber(pObject, inum) 
15717   
15718   
15719 -def fl_delete_folder_byname(pObject, name): 
15720      """ fl_delete_folder_byname(pObject, name) 
15721      """ 
15722   
15723      _fl_delete_folder_byname = cfuncproto( 
15724              load_so_libforms(), "fl_delete_folder_byname", 
15725              None, [cty.POINTER(FL_OBJECT), STRING], 
15726              """void fl_delete_folder_byname(FL_OBJECT * ob, const char * name) 
15727              """) 
15728      sname = convert_to_string(name) 
15729      keep_elem_refs(pObject, name, sname) 
15730      _fl_delete_folder_byname(pObject, sname) 
15731   
15732   
15733 -def fl_set_folder(pObject, pForm): 
15734      """ fl_set_folder(pObject, pForm) 
15735      """ 
15736   
15737      _fl_set_folder = cfuncproto( 
15738              load_so_libforms(), "fl_set_folder", 
15739              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 
15740              """void fl_set_folder(FL_OBJECT * ob, FL_FORM * form) 
15741              """) 
15742      keep_elem_refs(pObject, pForm) 
15743      _fl_set_folder(pObject, pForm) 
15744   
15745   
15746 -def fl_set_folder_byname(pObject, name): 
15747      """ fl_set_folder_byname(pObject, name) 
15748      """ 
15749   
15750      _fl_set_folder_byname = cfuncproto( 
15751              load_so_libforms(), "fl_set_folder_byname", 
15752              None, [cty.POINTER(FL_OBJECT), STRING], 
15753              """void fl_set_folder_byname(FL_OBJECT * ob, const char * name) 
15754              """) 
15755      sname = convert_to_string(name) 
15756      keep_elem_refs(pObject, name, sname) 
15757      _fl_set_folder_byname(pObject, name) 
15758   
15759   
15760 -def fl_set_folder_bynumber(pObject, num): 
15761      """ fl_set_folder_bynumber(pObject, num) 
15762      """ 
15763   
15764      _fl_set_folder_bynumber = cfuncproto( 
15765              load_so_libforms(), "fl_set_folder_bynumber", 
15766              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
15767              """void fl_set_folder_bynumber(FL_OBJECT * ob, int num) 
15768              """) 
15769      inum = convert_to_int(num) 
15770      keep_elem_refs(pObject, num, inum) 
15771      _fl_set_folder_bynumber(pObject, inum) 
15772   
15773   
15774 -def fl_get_folder(pObject): 
15775      """ 
15776          fl_get_folder(pObject) -> pForm 
15777   
15778          @param pObject : pointer to object 
15779      """ 
15780   
15781      _fl_get_folder = cfuncproto( 
15782              load_so_libforms(), "fl_get_folder", 
15783              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT)], 
15784              """FL_FORM * fl_get_folder(FL_OBJECT * ob) 
15785              """) 
15786      keep_elem_refs(pObject) 
15787      retval = _fl_get_folder(pObject) 
15788      return retval 
15789   
15790   
15791 -def fl_get_folder_number(pObject): 
15792      """ 
15793          fl_get_folder_number(pObject) -> folder num. 
15794   
15795          @param pObject : pointer to object 
15796      """ 
15797   
15798      _fl_get_folder_number = cfuncproto( 
15799              load_so_libforms(), "fl_get_folder_number", 
15800              cty.c_int, [cty.POINTER(FL_OBJECT)], 
15801              """int fl_get_folder_number(FL_OBJECT * ob) 
15802              """) 
15803      keep_elem_refs(pObject) 
15804      retval = _fl_get_folder_number(pObject) 
15805      return retval 
15806   
15807   
15808 -def fl_get_folder_name(pObject): 
15809      """ 
15810          fl_get_folder_name(pObject) -> name string 
15811   
15812          @param pObject : pointer to object 
15813      """ 
15814   
15815      _fl_get_folder_name = cfuncproto( 
15816              load_so_libforms(), "fl_get_folder_name", 
15817              STRING, [cty.POINTER(FL_OBJECT)], 
15818              """const char * fl_get_folder_name(FL_OBJECT * ob) 
15819              """) 
15820      keep_elem_refs(pObject) 
15821      retval = _fl_get_folder_name(pObject) 
15822      return retval 
15823   
15824   
15825 -def fl_get_tabfolder_numfolders(pObject): 
15826      """ 
15827          fl_get_tabfolder_numfolders(pObject) -> num. 
15828   
15829          @param pObject : pointer to object 
15830      """ 
15831   
15832      _fl_get_tabfolder_numfolders = cfuncproto( 
15833              load_so_libforms(), "fl_get_tabfolder_numfolders", 
15834              cty.c_int, [cty.POINTER(FL_OBJECT)], 
15835              """int fl_get_tabfolder_numfolders(FL_OBJECT * ob) 
15836              """) 
15837      keep_elem_refs(pObject) 
15838      retval = _fl_get_tabfolder_numfolders(pObject) 
15839      return retval 
15840   
15841   
15842 -def fl_get_active_folder(pObject): 
15843      """ 
15844          fl_get_active_folder(pObject) -> pForm 
15845   
15846          @param pObject : pointer to object 
15847      """ 
15848   
15849      _fl_get_active_folder = cfuncproto( 
15850              load_so_libforms(), "fl_get_active_folder", 
15851              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT)], 
15852              """FL_FORM * fl_get_active_folder(FL_OBJECT * ob) 
15853              """) 
15854      keep_elem_refs(pObject) 
15855      retval = _fl_get_active_folder(pObject) 
15856      return retval 
15857   
15858   
15859 -def fl_get_active_folder_number(pObject): 
15860      """ 
15861          fl_get_active_folder_number(pObject) -> num. 
15862   
15863          @param pObject : pointer to object 
15864      """ 
15865   
15866      _fl_get_active_folder_number = cfuncproto( 
15867              load_so_libforms(), "fl_get_active_folder_number", 
15868              cty.c_int, [cty.POINTER(FL_OBJECT)], 
15869              """int fl_get_active_folder_number(FL_OBJECT * ob) 
15870              """) 
15871      keep_elem_refs(pObject) 
15872      retval = _fl_get_active_folder_number(pObject) 
15873      return retval 
15874   
15875   
15876 -def fl_get_active_folder_name(pObject): 
15877      """ 
15878          fl_get_active_folder_name(pObject) -> name string 
15879   
15880          @param pObject : pointer to object 
15881      """ 
15882   
15883      _fl_get_active_folder_name = cfuncproto( 
15884              load_so_libforms(), "fl_get_active_folder_name", 
15885              STRING, [cty.POINTER(FL_OBJECT)], 
15886              """const char * fl_get_active_folder_name(FL_OBJECT * ob) 
15887              """) 
15888      keep_elem_refs(pObject) 
15889      retval = _fl_get_active_folder_name(pObject) 
15890      return retval 
15891   
15892   
15893  #def fl_get_folder_area(pObject, x, y, w, h)       *API change* 
15894 -def fl_get_folder_area(pObject): 
15895      """ 
15896          fl_get_folder_area(pObject) -> x, y, w, h 
15897   
15898          @param pObject : pointer to object 
15899      """ 
15900   
15901      _fl_get_folder_area = cfuncproto( 
15902              load_so_libforms(), "fl_get_folder_area", 
15903              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 
15904              cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 
15905              cty.POINTER(FL_Coord)], 
15906              """void fl_get_folder_area(FL_OBJECT * ob, FL_Coord * x, 
15907                 FL_Coord * y, FL_Coord * w, FL_Coord * h) 
15908              """) 
15909      x, px = make_int_and_pointer() 
15910      y, py = make_int_and_pointer() 
15911      w, pw = make_int_and_pointer() 
15912      h, ph = make_int_and_pointer() 
15913      keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 
15914      _fl_get_folder_area(pObject, px, py, pw, ph) 
15915      return x, y, w, h 
15916   
15917   
15918 -def fl_replace_folder_bynumber(pObject, num, pForm): 
15919      """ 
15920          fl_replace_folder_bynumber(pObject, num, pForm) 
15921   
15922          @param pObject : pointer to object 
15923      """ 
15924   
15925      _fl_replace_folder_bynumber = cfuncproto( 
15926              load_so_libforms(), "fl_replace_folder_bynumber", 
15927              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.POINTER(FL_FORM)], 
15928              """void fl_replace_folder_bynumber(FL_OBJECT * ob, int num, 
15929                 FL_FORM * form) 
15930              """) 
15931      inum = convert_to_int(num) 
15932      keep_elem_refs(pObject, num, pForm, inum) 
15933      _fl_replace_folder_bynumber(pObject, inum, pForm) 
15934   
15935   
15936 -def fl_set_tabfolder_autofit(pObject, num): 
15937      """ 
15938          fl_set_tabfolder_autofit(pObject, num) -> num. 
15939   
15940          @param pObject : pointer to object 
15941      """ 
15942   
15943      _fl_set_tabfolder_autofit = cfuncproto( 
15944              load_so_libforms(), "fl_set_tabfolder_autofit", 
15945              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
15946              """int fl_set_tabfolder_autofit(FL_OBJECT * ob, int y) 
15947              """) 
15948      inum = convert_to_int(num) 
15949      keep_elem_refs(pObject, num, inum) 
15950      retval = _fl_set_tabfolder_autofit(pObject, inum) 
15951      return retval 
15952   
15953   
15954 -def fl_set_default_tabfolder_corner(npixels): 
15955      """ 
15956          fl_set_default_tabfolder_corner(npixels) -> old pixels num. 
15957   
15958          Adjusts the corner pixels, changing appearance of the tabs. 
15959   
15960          @param npixels : number of corner pixels (default 3) 
15961      """ 
15962   
15963      _fl_set_default_tabfolder_corner = cfuncproto( 
15964              load_so_libforms(), "fl_set_default_tabfolder_corner", 
15965              cty.c_int, [cty.c_int], 
15966              """int fl_set_default_tabfolder_corner(int n): 
15967              """) 
15968      ipixels = convert_to_int(npixels) 
15969      keep_elem_refs(npixels, ipixels) 
15970      retval = _fl_set_default_tabfolder_corner(ipixels) 
15971      return retval 
15972   
15973   
15974 -def fl_set_tabfolder_offset(pObject, offset): 
15975      """ 
15976          fl_set_tabfolder_offset(pObject, offset) -> num. 
15977   
15978          @param pObject : pointer to tabfolder object 
15979      """ 
15980   
15981      _fl_set_tabfolder_offset = cfuncproto( 
15982              load_so_libforms(), "fl_set_tabfolder_offset", 
15983              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
15984              """int fl_set_tabfolder_offset(FL_OBJECT * ob, int offset) 
15985              """) 
15986      ioffset = convert_to_int(offset) 
15987      keep_elem_refs(pObject, offset, ioffset) 
15988      retval = _fl_set_tabfolder_offset(pObject, ioffset) 
15989      return retval 
15990   
15991   
15992   
15993  ################### 
15994  # forms.h (text.h) 
15995  ################### 
15996   
15997 -def fl_create_text(texttype, x, y, w, h, label): 
15998      """ 
15999          fl_create_text(texttype, x, y, w, h, label) -> pObject 
16000      """ 
16001   
16002      _fl_create_text = cfuncproto( 
16003              load_so_libforms(), "fl_create_text", 
16004              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
16005              FL_Coord, STRING], 
16006              """FL_OBJECT * fl_create_text(int type, FL_Coord x, FL_Coord y, 
16007                 FL_Coord w, FL_Coord h, const char * label) 
16008              """) 
16009      check_admitted_listvalues(texttype, TEXTTYPE_list) 
16010      itexttype = convert_to_int(texttype) 
16011      ix = convert_to_FL_Coord(x) 
16012      iy = convert_to_FL_Coord(y) 
16013      iw = convert_to_FL_Coord(w) 
16014      ih = convert_to_FL_Coord(h) 
16015      slabel = convert_to_string(label) 
16016      keep_elem_refs(texttype, x, y, w, h, label, itexttype, ix, iy, 
16017                     iw, ih, slabel) 
16018      retval = _fl_create_text(itexttype, ix, iy, iw, ih, slabel) 
16019      return retval 
16020   
16021   
16022 -def fl_add_text(texttype, x, y, w, h, label): 
16023      """ 
16024          fl_add_text(texttype, x, y, w, h, label) -> pObject 
16025      """ 
16026   
16027      _fl_add_text = cfuncproto( 
16028              load_so_libforms(), "fl_add_text", 
16029              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
16030              FL_Coord, STRING], 
16031              """FL_OBJECT * fl_add_text(int type, FL_Coord x, FL_Coord y, 
16032                 FL_Coord w, FL_Coord h, const char * label) 
16033              """) 
16034      check_admitted_listvalues(texttype, TEXTTYPE_list) 
16035      itexttype = convert_to_int(texttype) 
16036      ix = convert_to_FL_Coord(x) 
16037      iy = convert_to_FL_Coord(y) 
16038      iw = convert_to_FL_Coord(w) 
16039      ih = convert_to_FL_Coord(h) 
16040      slabel = convert_to_string(label) 
16041      keep_elem_refs(texttype, x, y, w, h, label, itexttype, ix, iy, 
16042                     iw, ih, slabel) 
16043      retval = _fl_add_text(itexttype, ix, iy, iw, ih, slabel) 
16044      return retval 
16045   
16046   
16047   
16048  ######################### 
16049  # forms.h (thumbwheel.h) 
16050  ######################### 
16051   
16052 -def fl_get_thumbwheel_value(pObject): 
16053      """ 
16054          fl_get_thumbwheel_value(pObject) -> num. 
16055   
16056          @param pObject : pointer to object 
16057      """ 
16058   
16059      _fl_get_thumbwheel_value = cfuncproto( 
16060              load_so_libforms(), "fl_get_thumbwheel_value", 
16061              cty.c_double, [cty.POINTER(FL_OBJECT)], 
16062              """double fl_get_thumbwheel_value(FL_OBJECT * ob) 
16063              """) 
16064      keep_elem_refs(pObject) 
16065      retval = _fl_get_thumbwheel_value(pObject) 
16066      return retval 
16067   
16068   
16069 -def fl_set_thumbwheel_value(pObject, value): 
16070      """ 
16071          fl_set_thumbwheel_value(pObject, value) 
16072   
16073          @param pObject : pointer to object 
16074      """ 
16075   
16076      _fl_set_thumbwheel_value = cfuncproto( 
16077              load_so_libforms(), "fl_set_thumbwheel_value", 
16078              cty.c_double, [cty.POINTER(FL_OBJECT), cty.c_double], 
16079              """double fl_set_thumbwheel_value(FL_OBJECT * ob, double value) 
16080              """) 
16081      fvalue = convert_to_double(value) 
16082      keep_elem_refs(pObject, value, fvalue) 
16083      retval = _fl_set_thumbwheel_value(pObject, fvalue) 
16084      return retval 
16085   
16086   
16087 -def fl_get_thumbwheel_step(pObject): 
16088      """ 
16089          fl_get_thumbwheel_step(pObject) -> num. 
16090   
16091          @param pObject : pointer to object 
16092      """ 
16093   
16094      _fl_get_thumbwheel_step = cfuncproto( 
16095              load_so_libforms(), "fl_get_thumbwheel_step", 
16096              cty.c_double, [cty.POINTER(FL_OBJECT)], 
16097              """double fl_get_thumbwheel_step(FL_OBJECT * ob) 
16098              """) 
16099      keep_elem_refs(pObject) 
16100      retval = _fl_get_thumbwheel_step(pObject) 
16101      return retval 
16102   
16103   
16104 -def fl_set_thumbwheel_step(pObject, step): 
16105      """ 
16106          fl_set_thumbwheel_step(pObject, step) -> num. 
16107   
16108          @param pObject : pointer to object 
16109      """ 
16110   
16111      _fl_set_thumbwheel_step = cfuncproto( 
16112              load_so_libforms(), "fl_set_thumbwheel_step", 
16113              cty.c_double, [cty.POINTER(FL_OBJECT), cty.c_double], 
16114              """double fl_set_thumbwheel_step(FL_OBJECT * ob, double step) 
16115              """) 
16116      fstep = convert_to_double(step) 
16117      keep_elem_refs(pObject, step, fstep) 
16118      retval = _fl_set_thumbwheel_step(pObject, fstep) 
16119      return retval 
16120   
16121   
16122 -def fl_set_thumbwheel_return(pObject, when): 
16123      """ 
16124          fl_set_thumbwheel_return(pObject, when) -> num. 
16125   
16126          @param pObject : pointer to object 
16127      """ 
16128   
16129      _fl_set_thumbwheel_return = cfuncproto( 
16130              load_so_libforms(), "fl_set_thumbwheel_return", 
16131              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
16132              """int fl_set_thumbwheel_return(FL_OBJECT * ob, int how) 
16133              """) 
16134      check_admitted_listvalues(when, RETURN_list) 
16135      iwhen = convert_to_int(when) 
16136      keep_elem_refs(pObject, when, iwhen) 
16137      retval = _fl_set_thumbwheel_return(pObject, when) 
16138      return retval 
16139   
16140   
16141 -def fl_set_thumbwheel_crossover(pObject, flag): 
16142      """ 
16143          fl_set_thumbwheel_crossover(pObject, flag) -> num. 
16144   
16145          @param pObject : pointer to object 
16146      """ 
16147   
16148      _fl_set_thumbwheel_crossover = cfuncproto( 
16149              load_so_libforms(), "fl_set_thumbwheel_crossover", 
16150              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
16151              """int fl_set_thumbwheel_crossover(FL_OBJECT * ob, int flag) 
16152              """) 
16153      iflag = convert_to_int(flag) 
16154      keep_elem_refs(pObject, flag, iflag) 
16155      retval = _fl_set_thumbwheel_crossover(pObject, iflag) 
16156      return retval 
16157   
16158   
16159 -def fl_set_thumbwheel_bounds(pObject, minbound, maxbound): 
16160      """ 
16161          fl_set_thumbwheel_bounds(pObject, minbound, maxbound) 
16162   
16163          @param pObject : pointer to object 
16164      """ 
16165   
16166      _fl_set_thumbwheel_bounds = cfuncproto( 
16167              load_so_libforms(), "fl_set_thumbwheel_bounds", 
16168              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
16169              """void fl_set_thumbwheel_bounds(FL_OBJECT * ob, double min, 
16170                 double max) 
16171              """) 
16172      fminbound = convert_to_double(minbound) 
16173      fmaxbound = convert_to_double(maxbound) 
16174      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
16175      _fl_set_thumbwheel_bounds(pObject, fminbound, fmaxbound) 
16176   
16177   
16178  #def fl_get_thumbwheel_bounds(pObject, minbound, maxbound)       *API change* 
16179 -def fl_get_thumbwheel_bounds(pObject): 
16180      """ 
16181          fl_get_thumbwheel_bounds(pObject) -> minbound, maxbound 
16182   
16183          @param pObject : pointer to thumbwheel object 
16184      """ 
16185   
16186      _fl_get_thumbwheel_bounds = cfuncproto( 
16187              load_so_libforms(), "fl_get_thumbwheel_bounds", 
16188              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
16189              cty.POINTER(cty.c_double)], 
16190              """void fl_get_thumbwheel_bounds(FL_OBJECT * ob, double * min, 
16191                 double * max) 
16192              """) 
16193      minbound, pminbound = make_double_and_pointer() 
16194      maxbound, pmaxbound = make_double_and_pointer() 
16195      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
16196      _fl_get_thumbwheel_bounds(pObject, pminbound, pmaxbound) 
16197      return minbound, maxbound 
16198   
16199   
16200 -def fl_create_thumbwheel(wheeltype, x, y, w, h, label): 
16201      """ 
16202          fl_create_thumbwheel(wheeltype, x, y, w, h, label) -> pObject 
16203      """ 
16204   
16205      _fl_create_thumbwheel = cfuncproto( 
16206              load_so_libforms(), "fl_create_thumbwheel", 
16207              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
16208              FL_Coord, STRING], 
16209              """FL_OBJECT * fl_create_thumbwheel(int type, FL_Coord x, 
16210                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
16211              """) 
16212      check_admitted_listvalues(wheeltype, THUMBWHEELTYPE_list) 
16213      iwheeltype = convert_to_int(wheeltype) 
16214      ix = convert_to_FL_Coord(x) 
16215      iy = convert_to_FL_Coord(y) 
16216      iw = convert_to_FL_Coord(w) 
16217      ih = convert_to_FL_Coord(h) 
16218      slabel = convert_to_string(label) 
16219      keep_elem_refs(wheeltype, x, y, w, h, label, iwheeltype, ix, iy, 
16220                     iw, ih, slabel) 
16221      retval = _fl_create_thumbwheel(iwheeltype, ix, iy, iw, ih, slabel) 
16222      return retval 
16223   
16224   
16225 -def fl_add_thumbwheel(wheeltype, x, y, w, h, label): 
16226      """ 
16227          fl_add_thumbwheel(wheeltype, x, y, w, h, label) -> pObject 
16228      """ 
16229   
16230      _fl_add_thumbwheel = cfuncproto( 
16231              load_so_libforms(), "fl_add_thumbwheel", 
16232              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
16233              FL_Coord, STRING], 
16234              """FL_OBJECT * fl_add_thumbwheel(int type, FL_Coord x, FL_Coord y, 
16235                 FL_Coord w, FL_Coord h, const char * label) 
16236              """) 
16237      check_admitted_listvalues(wheeltype, THUMBWHEELTYPE_list) 
16238      iwheeltype = convert_to_int(wheeltype) 
16239      ix = convert_to_FL_Coord(x) 
16240      iy = convert_to_FL_Coord(y) 
16241      iw = convert_to_FL_Coord(w) 
16242      ih = convert_to_FL_Coord(h) 
16243      slabel = convert_to_string(label) 
16244      keep_elem_refs(wheeltype, x, y, w, h, label, iwheeltype, ix, iy, 
16245                     iw, ih, slabel) 
16246      retval = _fl_add_thumbwheel(iwheeltype, ix, iy, iw, ih, slabel) 
16247      return retval 
16248   
16249   
16250   
16251  ###################### 
16252  # forms.h (timer.h) 
16253  # Object Class: Timer 
16254  ###################### 
16255   
16256  # Routines 
16257   
16258 -def fl_create_timer(timertype, x, y, w, h, label): 
16259      """ 
16260          fl_create_timer(timertype, x, y, w, h, label) -> pObject 
16261      """ 
16262   
16263      _fl_create_timer = cfuncproto( 
16264              load_so_libforms(), "fl_create_timer", 
16265              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
16266              FL_Coord, STRING], 
16267              """FL_OBJECT * fl_create_timer(int type, FL_Coord x, FL_Coord y, 
16268              FL_Coord w, FL_Coord h, const char * label) 
16269              """) 
16270      check_admitted_listvalues(timertype, TIMERTYPE_list) 
16271      itimertype = convert_to_int(timertype) 
16272      ix = convert_to_FL_Coord(x) 
16273      iy = convert_to_FL_Coord(y) 
16274      iw = convert_to_FL_Coord(w) 
16275      ih = convert_to_FL_Coord(h) 
16276      slabel = convert_to_string(label) 
16277      keep_elem_refs(timertype, x, y, w, h, label, itimertype, ix, iy, 
16278                     iw, ih, slabel) 
16279      retval = _fl_create_timer(itimertype, ix, iy, iw, ih, slabel) 
16280      return retval 
16281   
16282   
16283 -def fl_add_timer(timertype, x, y, w, h, label): 
16284      """ 
16285          fl_add_timer(timertype, x, y, w, h, label) -> pObject 
16286      """ 
16287   
16288      _fl_add_timer = cfuncproto( 
16289              load_so_libforms(), "fl_add_timer", 
16290              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
16291              FL_Coord, STRING], 
16292              """FL_OBJECT * fl_add_timer(int type, FL_Coord x, FL_Coord y, 
16293              FL_Coord w, FL_Coord h, const char * label) 
16294              """) 
16295      check_admitted_listvalues(timertype, TIMERTYPE_list) 
16296      itimertype = convert_to_int(timertype) 
16297      ix = convert_to_FL_Coord(x) 
16298      iy = convert_to_FL_Coord(y) 
16299      iw = convert_to_FL_Coord(w) 
16300      ih = convert_to_FL_Coord(h) 
16301      slabel = convert_to_string(label) 
16302      keep_elem_refs(timertype, x, y, w, h, label, itimertype, ix, iy, 
16303                     iw, ih, slabel) 
16304      retval = _fl_add_timer(itimertype, ix, iy, iw, ih, slabel) 
16305      return retval 
16306   
16307   
16308 -def fl_set_timer(pObject, total): 
16309      """ 
16310          fl_set_timer(pObject, total) 
16311   
16312          @param pObject : pointer to object 
16313      """ 
16314   
16315      _fl_set_timer = cfuncproto( 
16316              load_so_libforms(), "fl_set_timer", 
16317              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
16318              """void fl_set_timer(FL_OBJECT * ob, double total) 
16319              """) 
16320      ftotal = convert_to_double(total) 
16321      keep_elem_refs(pObject, total, ftotal) 
16322      _fl_set_timer(pObject, ftotal) 
16323   
16324   
16325 -def fl_get_timer(pObject): 
16326      """ 
16327          fl_get_timer(pObject) -> num. 
16328   
16329          @param pObject : pointer to object 
16330      """ 
16331   
16332      _fl_get_timer = cfuncproto( 
16333              load_so_libforms(), "fl_get_timer", 
16334              cty.c_double, [cty.POINTER(FL_OBJECT)], 
16335              """double fl_get_timer(FL_OBJECT * ob) 
16336              """) 
16337      keep_elem_refs(pObject) 
16338      retval = _fl_get_timer(pObject) 
16339      return retval 
16340   
16341   
16342 -def fl_set_timer_countup(pObject, yes): 
16343      """ 
16344          fl_set_timer_countup(pObject, yes) 
16345   
16346          @param pObject : pointer to object 
16347      """ 
16348   
16349      _fl_set_timer_countup = cfuncproto( 
16350              load_so_libforms(), "fl_set_timer_countup", 
16351              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
16352              """void fl_set_timer_countup(FL_OBJECT * ob, int yes) 
16353              """) 
16354      iyes = convert_to_int(yes) 
16355      keep_elem_refs(pObject, yes, iyes) 
16356      _fl_set_timer_countup(pObject, iyes) 
16357   
16358   
16359  FL_TIMER_FILTER = cty.CFUNCTYPE(STRING, cty.POINTER(FL_OBJECT), cty.c_double) 
16360   
16361 -def fl_set_timer_filter(pObject, py_TimerFilter): 
16362      """ 
16363          fl_set_timer_filter(pObject, py_TimerFilter) -> timer_filter func. 
16364   
16365          @param pObject : pointer to object 
16366          @param py_TimerFilter : python function, fn(pObject, valfloat) -> 
16367             string 
16368      """ 
16369   
16370      _fl_set_timer_filter = cfuncproto( 
16371              load_so_libforms(), "fl_set_timer_filter", 
16372              FL_TIMER_FILTER, [cty.POINTER(FL_OBJECT), FL_TIMER_FILTER], 
16373              """FL_TIMER_FILTER fl_set_timer_filter(FL_OBJECT * ob, 
16374                 FL_TIMER_FILTER filter) 
16375              """) 
16376      c_TimerFilter = FL_TIMER_FILTER(py_TimerFilter) 
16377      keep_cfunc_refs(c_TimerFilter, py_TimerFilter) 
16378      keep_elem_refs(pObject) 
16379      retval = _fl_set_timer_filter(pObject, c_TimerFilter) 
16380      return retval 
16381   
16382   
16383 -def fl_suspend_timer(pObject): 
16384      """ 
16385          fl_suspend_timer(pObject) 
16386   
16387          @param pObject : pointer to object 
16388      """ 
16389   
16390      _fl_suspend_timer = cfuncproto( 
16391              load_so_libforms(), "fl_suspend_timer", 
16392              None, [cty.POINTER(FL_OBJECT)], 
16393              """void fl_suspend_timer(FL_OBJECT * ob) 
16394              """) 
16395      keep_elem_refs(pObject) 
16396      _fl_suspend_timer(pObject) 
16397   
16398   
16399 -def fl_resume_timer(pObject): 
16400      """ 
16401          fl_resume_timer(pObject) 
16402   
16403          Resume timer previously paused. 
16404   
16405          @param pObject : pointer to timer object 
16406      """ 
16407   
16408      _fl_resume_timer = cfuncproto( 
16409              load_so_libforms(), "fl_resume_timer", 
16410              None, [cty.POINTER(FL_OBJECT)], 
16411              """void fl_resume_timer(FL_OBJECT * ob) 
16412              """) 
16413      keep_elem_refs(pObject) 
16414      _fl_resume_timer(pObject) 
16415   
16416   
16417   
16418  ############################### 
16419  # forms.h (xpopup.h) 
16420  # Prototypes for xpop-up menus 
16421  ############################### 
16422   
16423 -def fl_setpup_entries(popupid, pPopupEntry): 
16424      """ 
16425          fl_setpup_entries(popupid, pPopupEntry) -> num. 
16426      """ 
16427   
16428      _fl_setpup_entries = cfuncproto( 
16429              load_so_libforms(), "fl_setpup_entries", 
16430              cty.c_int, [cty.c_int, cty.POINTER(FL_PUP_ENTRY)], 
16431              """int fl_setpup_entries(int nm, FL_PUP_ENTRY * entries) 
16432              """) 
16433      ipopupid = convert_to_int(popupid) 
16434      keep_elem_refs(popupid, pPopupEntry, ipopupid) 
16435      retval = _fl_setpup_entries(ipopupid, pPopupEntry) 
16436      return retval 
16437   
16438   
16439 -def fl_newpup(win): 
16440      """ 
16441          fl_newpup(win) -> num. 
16442      """ 
16443   
16444      _fl_newpup = cfuncproto( 
16445              load_so_libforms(), "fl_newpup", 
16446              cty.c_int, [Window], 
16447              """int fl_newpup(Window win) 
16448              """) 
16449      ulwin = convert_to_Window(win) 
16450      keep_elem_refs(win, ulwin) 
16451      retval = _fl_newpup(ulwin) 
16452      return retval 
16453   
16454   
16455 -def fl_defpup(win, pupstr): 
16456      """ 
16457          fl_defpup(win, pupstr) -> num. 
16458      """ 
16459   
16460      _fl_defpup = cfuncproto( 
16461              load_so_libforms(), "fl_defpup", 
16462              cty.c_int, [Window, STRING], 
16463              """int fl_defpup(Window win, const char * str): 
16464              """) 
16465      ulwin = convert_to_Window(win) 
16466      spupstr = convert_to_string(pupstr) 
16467      keep_elem_refs(win, pupstr, ulwin, spupstr) 
16468      retval = _fl_defpup(ulwin, spupstr) 
16469      return retval 
16470   
16471   
16472 -def fl_addtopup(popupid, pupstr): 
16473      """ 
16474          fl_addtopup(popupid, pupstr) -> num. 
16475      """ 
16476   
16477      _fl_addtopup = cfuncproto( 
16478              load_so_libforms(), "fl_addtopup", 
16479              cty.c_int, [cty.c_int, STRING], 
16480              """int fl_addtopup(int n, const char * str) 
16481              """) 
16482      ipopupid = convert_to_int(popupid) 
16483      spupstr = convert_to_string(pupstr) 
16484      keep_elem_refs(popupid, pupstr, ipopupid, spupstr) 
16485      retval = _fl_addtopup(ipopupid, spupstr) 
16486      return retval 
16487   
16488   
16489 -def fl_setpup_mode(popupid, itemval, mode): 
16490      """ 
16491          fl_setpup_mode(popupid, itemval, mode) -> num. 
16492      """ 
16493   
16494      _fl_setpup_mode = cfuncproto( 
16495              load_so_libforms(), "fl_setpup_mode", 
16496              cty.c_int, [cty.c_int, cty.c_int, cty.c_uint], 
16497              """int fl_setpup_mode(int nm, int ni, unsigned int mode) 
16498              """) 
16499      ipopupid = convert_to_int(popupid) 
16500      iitemval = convert_to_int(itemval) 
16501      uimode = convert_to_uint(mode) 
16502      keep_elem_refs(popupid, itemval, mode, ipopupid, iitemval, uimode) 
16503      retval = _fl_setpup_mode(ipopupid, iitemval, uimode) 
16504      return retval 
16505   
16506   
16507 -def fl_freepup(popupid): 
16508      """ 
16509          fl_freepup(popupid) 
16510      """ 
16511   
16512      _fl_freepup = cfuncproto( 
16513              load_so_libforms(), "fl_freepup", 
16514              None, [cty.c_int], 
16515              """void fl_freepup(int n) 
16516              """) 
16517      ipopupid = convert_to_int(popupid) 
16518      keep_elem_refs(popupid, ipopupid) 
16519      _fl_freepup(ipopupid) 
16520   
16521   
16522 -def fl_dopup(popupid): 
16523      """ 
16524          fl_dopup(popupid) -> num. 
16525      """ 
16526   
16527      _fl_dopup = cfuncproto( 
16528              load_so_libforms(), "fl_dopup", 
16529              cty.c_int, [cty.c_int], 
16530              """int fl_dopup(int n) 
16531              """) 
16532      ipopupid = convert_to_int(popupid) 
16533      keep_elem_refs(popupid, ipopupid) 
16534      retval = _fl_dopup(ipopupid) 
16535      return retval 
16536   
16537   
16538 -def fl_setpup_default_cursor(cursor): 
16539      """ 
16540          fl_setpup_default_cursor(cursor) -> cursor 
16541      """ 
16542   
16543      _fl_setpup_default_cursor = cfuncproto( 
16544              load_so_libforms(), "fl_setpup_default_cursor", 
16545              Cursor, [cty.c_int], 
16546              """Cursor fl_setpup_default_cursor(int cursor): 
16547              """) 
16548      icursor = convert_to_int(cursor) 
16549      keep_elem_refs(cursor, icursor) 
16550      retval = _fl_setpup_default_cursor(icursor) 
16551      return retval 
16552   
16553   
16554 -def fl_setpup_default_color(fgcolr, bgcolr): 
16555      """ 
16556          fl_setpup_default_color(fgcolr, bgcolr) 
16557      """ 
16558   
16559      _fl_setpup_default_color = cfuncproto( 
16560              load_so_libforms(), "fl_setpup_default_color", 
16561              None, [FL_COLOR, FL_COLOR], 
16562              """void fl_setpup_default_color(FL_COLOR fg, FL_COLOR bg) 
16563              """) 
16564      ulfgcolr = convert_to_FL_COLOR(fgcolr) 
16565      ulbgcolr = convert_to_FL_COLOR(bgcolr) 
16566      keep_elem_refs(fgcolr, bgcolr, ulfgcolr, ulbgcolr) 
16567      _fl_setpup_default_color(ulfgcolr, ulbgcolr) 
16568   
16569   
16570 -def fl_setpup_default_pup_checked_color(colr): 
16571      """ 
16572          fl_setpup_default_pup_checked_color(colr): 
16573      """ 
16574   
16575      _fl_setpup_default_pup_checked_color = cfuncproto( 
16576              load_so_libforms(), "fl_setpup_default_pup_checked_color", 
16577              None, [FL_COLOR], 
16578              """void fl_setpup_default_pup_checked_color(FL_COLOR col) 
16579              """) 
16580      ulcolr = convert_to_FL_COLOR(colr) 
16581      keep_elem_refs(colr, ulcolr) 
16582      _fl_setpup_default_pup_checked_color(ulcolr) 
16583   
16584   
16585 -def fl_setpup_default_fontsize(size): 
16586      """ 
16587          fl_setpup_default_fontsize(size) -> num. 
16588      """ 
16589   
16590      _fl_setpup_default_fontsize = cfuncproto( 
16591              load_so_libforms(), "fl_setpup_default_fontsize", 
16592              cty.c_int, [cty.c_int], 
16593              """int fl_setpup_default_fontsize(int size)    DEPRECATED? 
16594              """) 
16595      isize = convert_to_int(size) 
16596      keep_elem_refs(size, isize) 
16597      retval = _fl_setpup_default_fontsize(isize) 
16598      return retval 
16599   
16600   
16601 -def fl_setpup_default_fontstyle(style): 
16602      """ 
16603          fl_setpup_default_fontstyle(style) -> num. 
16604      """ 
16605   
16606      _fl_setpup_default_fontstyle = cfuncproto( 
16607              load_so_libforms(), "fl_setpup_default_fontstyle", 
16608              cty.c_int, [cty.c_int], 
16609              """int fl_setpup_default_fontstyle(int style) 
16610              """) 
16611      istyle = convert_to_int(style) 
16612      keep_elem_refs(style, istyle) 
16613      retval = _fl_setpup_default_fontstyle(istyle) 
16614      return retval 
16615   
16616   
16617  fl_setpup_fontsize = fl_setpup_default_fontsize 
16618  fl_setpup_fontstyle = fl_setpup_default_fontstyle 
16619  fl_setpup_color = fl_setpup_default_color 
16620  fl_setpup_default_checkcolor = fl_setpup_default_pup_checked_color 
16621  fl_setpup_checkcolor = fl_setpup_default_pup_checked_color 
16622   
16623   
16624 -def fl_setpup_default_bw(bw): 
16625      """ 
16626          fl_setpup_default_bw(bw) -> num. 
16627      """ 
16628   
16629      _fl_setpup_default_bw = cfuncproto( 
16630              load_so_libforms(), "fl_setpup_default_bw", 
16631              cty.c_int, [cty.c_int], 
16632              """int fl_setpup_default_bw(int bw): 
16633              """) 
16634      ibw = convert_to_int(bw) 
16635      keep_elem_refs(bw, ibw) 
16636      retval = _fl_setpup_default_bw(ibw) 
16637      return retval 
16638   
16639   
16640 -def fl_setpup_shortcut(popupid, itemval, hotkeystxt): 
16641      """ 
16642          fl_setpup_shortcut(popupid, itemval, hotkeystxt) 
16643      """ 
16644   
16645      _fl_setpup_shortcut = cfuncproto( 
16646              load_so_libforms(), "fl_setpup_shortcut", 
16647              None, [cty.c_int, cty.c_int, STRING], 
16648              """void fl_setpup_shortcut(int nm, int ni, const char * sc) 
16649              """) 
16650      ipopupid = convert_to_int(popupid) 
16651      iitemval = convert_to_int(itemval) 
16652      shotkeystxt = convert_to_string(hotkeystxt) 
16653      keep_elem_refs(popupid, itemval, hotkeystxt, ipopupid, iitemval, \ 
16654                     shotkeystxt) 
16655      _fl_setpup_shortcut(ipopupid, iitemval, shotkeystxt) 
16656   
16657   
16658 -def fl_setpup_position(x, y): 
16659      """ 
16660          fl_setpup_position(x, y) 
16661      """ 
16662   
16663      _fl_setpup_position = cfuncproto( 
16664              load_so_libforms(), "fl_setpup_position", 
16665              None, [cty.c_int, cty.c_int], 
16666              """void fl_setpup_position(int x, int y) 
16667              """) 
16668      ix = convert_to_int(x) 
16669      iy = convert_to_int(y) 
16670      keep_elem_refs(x, y, ix, iy) 
16671      _fl_setpup_position(ix, iy) 
16672   
16673   
16674 -def fl_setpup_selection(popupid, itemval): 
16675      """ 
16676          fl_setpup_selection(popupid, itemval) 
16677      """ 
16678   
16679      _fl_setpup_selection = cfuncproto( 
16680              load_so_libforms(), "fl_setpup_selection", 
16681              None, [cty.c_int, cty.c_int], 
16682              """void fl_setpup_selection(int nm, int ni) 
16683              """) 
16684      ipopupid = convert_to_int(popupid) 
16685      iitemval = convert_to_int(itemval) 
16686      keep_elem_refs(popupid, itemval, ipopupid, iitemval) 
16687      _fl_setpup_selection(ipopupid, iitemval) 
16688   
16689   
16690 -def fl_setpup_shadow(popupid, flag): 
16691      """ 
16692          fl_setpup_shadow(popupid, flag) 
16693      """ 
16694   
16695      _fl_setpup_shadow = cfuncproto( 
16696              load_so_libforms(), "fl_setpup_shadow", 
16697              None, [cty.c_int, cty.c_int], 
16698              """void fl_setpup_shadow(int n, int y) 
16699              """) 
16700      ipopupid = convert_to_int(popupid) 
16701      iflag = convert_to_int(flag) 
16702      keep_elem_refs(popupid, flag, ipopupid, iflag) 
16703      _fl_setpup_shadow(ipopupid, iflag) 
16704   
16705   
16706 -def fl_setpup_softedge(popupid, flag): 
16707      """ 
16708          fl_setpup_softedge(popupid, flag) 
16709      """ 
16710   
16711      _fl_setpup_softedge = cfuncproto( 
16712              load_so_libforms(), "fl_setpup_softedge", 
16713              None, [cty.c_int, cty.c_int], 
16714              """void fl_setpup_softedge(int n, int y) 
16715              """) 
16716      ipopupid = convert_to_int(popupid) 
16717      iflag = convert_to_int(flag) 
16718      keep_elem_refs(popupid, flag, ipopupid, iflag) 
16719      _fl_setpup_softedge(ipopupid, iflag) 
16720   
16721   
16722 -def fl_setpup_bw(popupid, bw): 
16723      """ 
16724          fl_setpup_bw(popupid, bw) 
16725      """ 
16726   
16727      _fl_setpup_bw = cfuncproto( 
16728              load_so_libforms(), "fl_setpup_bw", 
16729              None, [cty.c_int, cty.c_int], 
16730              """void fl_setpup_bw(int n, int bw) 
16731              """) 
16732      ipopupid = convert_to_int(popupid) 
16733      ibw = convert_to_int(bw) 
16734      keep_elem_refs(popupid, bw, ipopupid, ibw) 
16735      _fl_setpup_bw(ipopupid, ibw) 
16736   
16737   
16738 -def fl_setpup_title(popupid, title): 
16739      """ 
16740          fl_setpup_title(popupid, title) 
16741      """ 
16742   
16743      _fl_setpup_title = cfuncproto( 
16744              load_so_libforms(), "fl_setpup_title", 
16745              None, [cty.c_int, STRING], 
16746              """void fl_setpup_title(int nm, const char * title) 
16747              """) 
16748      ipopupid = convert_to_int(popupid) 
16749      stitle = convert_to_string(title) 
16750      keep_elem_refs(popupid, title, ipopupid, stitle) 
16751      _fl_setpup_title(ipopupid, stitle) 
16752   
16753   
16754  FL_PUP_ENTERCB = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 
16755   
16756 -def fl_setpup_entercb(popupid, py_PupEnterCb, data): 
16757      """ 
16758          fl_setpup_entercb(popupid, py_PupEnterCb, data) -> pup_entercb 
16759      """ 
16760   
16761      _fl_setpup_entercb = cfuncproto( 
16762              load_so_libforms(), "fl_setpup_entercb", 
16763              FL_PUP_ENTERCB, [cty.c_int, FL_PUP_ENTERCB, cty.c_void_p], 
16764              """FL_PUP_ENTERCB fl_setpup_entercb(int nm, FL_PUP_ENTERCB cb, 
16765                 void * data) 
16766              """) 
16767      ipopupid = convert_to_int(popupid) 
16768      c_PupEnterCb = FL_PUP_ENTERCB(py_PupEnterCb) 
16769      pdata = cty.cast(data, cty.c_void_p) 
16770      keep_cfunc_refs(c_PupEnterCb, py_PupEnterCb) 
16771      keep_elem_refs(popupid, data, ipopupid, pdata) 
16772      retval = _fl_setpup_entercb(ipopupid, c_PupEnterCb, pdata) 
16773      return retval 
16774   
16775   
16776  FL_PUP_LEAVECB = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 
16777   
16778 -def fl_setpup_leavecb(popupid, py_LeaveCb, data): 
16779      """ 
16780          fl_setpup_leavecb(popupid, py_LeaveCb, data) -> pup_leavecb 
16781      """ 
16782   
16783      _fl_setpup_leavecb = cfuncproto( 
16784              load_so_libforms(), "fl_setpup_leavecb", 
16785              FL_PUP_LEAVECB, [cty.c_int, FL_PUP_LEAVECB, cty.c_void_p], 
16786              """FL_PUP_LEAVECB fl_setpup_leavecb(int nm, FL_PUP_LEAVECB cb, 
16787                 void * data) 
16788              """) 
16789      ipopupid = convert_to_int(popupid) 
16790      c_LeaveCb = FL_PUP_LEAVECB(py_LeaveCb) 
16791      pdata = cty.cast(data, cty.c_void_p) 
16792      keep_cfunc_refs(c_LeaveCb, py_LeaveCb) 
16793      keep_elem_refs(popupid, data, ipopupid, pdata) 
16794      retval = _fl_setpup_leavecb(ipopupid, c_LeaveCb, pdata) 
16795      return retval 
16796   
16797   
16798 -def fl_setpup_pad(popupid, padw, padh): 
16799      """ 
16800          fl_setpup_pad(popupid, padw, padh) 
16801      """ 
16802   
16803      _fl_setpup_pad = cfuncproto( 
16804              load_so_libforms(), "fl_setpup_pad", 
16805              None, [cty.c_int, cty.c_int, cty.c_int], 
16806              """void fl_setpup_pad(int n, int padw, int padh) 
16807              """) 
16808      ipopupid = convert_to_int(popupid) 
16809      ipadw = convert_to_int(padw) 
16810      ipadh = convert_to_int(padh) 
16811      keep_elem_refs(popupid, padw, padh, ipopupid, ipadw, ipadh) 
16812      _fl_setpup_pad(ipopupid, ipadw, ipadh) 
16813   
16814   
16815 -def fl_setpup_cursor(popupid, cursor): 
16816      """ 
16817          fl_setpup_cursor(popupid, cursor) -> cursor 
16818      """ 
16819   
16820      _fl_setpup_cursor = cfuncproto( 
16821              load_so_libforms(), "fl_setpup_cursor", 
16822              Cursor, [cty.c_int, cty.c_int], 
16823              """Cursor fl_setpup_cursor(int nm, int cursor) 
16824              """) 
16825      ipopupid = convert_to_int(popupid) 
16826      icursor = convert_to_int(cursor) 
16827      keep_elem_refs(popupid, cursor, ipopupid, icursor) 
16828      retval = _fl_setpup_cursor(ipopupid, icursor) 
16829      return retval 
16830   
16831   
16832 -def fl_setpup_maxpup(newmaxnum): 
16833      """ 
16834          fl_setpup_maxpup(newmaxnum) -> num. 
16835      """ 
16836   
16837      _fl_setpup_maxpup = cfuncproto( 
16838              load_so_libforms(), "fl_setpup_maxpup", 
16839              cty.c_int, [cty.c_int], 
16840              """int fl_setpup_maxpup(int n) 
16841              """) 
16842      inewmaxnum = convert_to_int(newmaxnum) 
16843      keep_elem_refs(newmaxnum, inewmaxnum) 
16844      retval = _fl_setpup_maxpup(inewmaxnum) 
16845      return retval 
16846   
16847   
16848 -def fl_getpup_mode(popupid, itemval): 
16849      """ 
16850          fl_getpup_mode(popupid, itemval) -> num. 
16851      """ 
16852   
16853      _fl_getpup_mode = cfuncproto( 
16854              load_so_libforms(), "fl_getpup_mode", 
16855              cty.c_uint, [cty.c_int, cty.c_int], 
16856              """unsigned int fl_getpup_mode(int nm, int ni) 
16857              """) 
16858      ipopupid = convert_to_int(popupid) 
16859      iitemval = convert_to_int(itemval) 
16860      keep_elem_refs(popupid, itemval, ipopupid, iitemval) 
16861      retval = _fl_getpup_mode(ipopupid, iitemval) 
16862      return retval 
16863   
16864   
16865 -def fl_getpup_text(popupid, itemval): 
16866      """ 
16867          fl_getpup_text(popupid, itemval) -> text string 
16868      """ 
16869   
16870      _fl_getpup_text = cfuncproto( 
16871              load_so_libforms(), "fl_getpup_text", 
16872              STRING, [cty.c_int, cty.c_int], 
16873              """const char * fl_getpup_text(int nm, int ni) 
16874              """) 
16875      ipopupid = convert_to_int(popupid) 
16876      iitemval = convert_to_int(itemval) 
16877      keep_elem_refs(popupid, itemval, ipopupid, iitemval) 
16878      retval = _fl_getpup_text(ipopupid, iitemval) 
16879      return retval 
16880   
16881   
16882 -def fl_showpup(popupid): 
16883      """ 
16884          fl_showpup(popupid) 
16885      """ 
16886   
16887      _fl_showpup = cfuncproto( 
16888              load_so_libforms(), "fl_showpup", 
16889              None, [cty.c_int], 
16890              """void fl_showpup(int n) 
16891              """) 
16892      ipopupid = convert_to_int(popupid) 
16893      keep_elem_refs(popupid, ipopupid) 
16894      _fl_showpup(ipopupid) 
16895   
16896   
16897 -def fl_hidepup(popupid): 
16898      """ 
16899          fl_hidepup(popupid) 
16900      """ 
16901   
16902      _fl_hidepup = cfuncproto( 
16903              load_so_libforms(), "fl_hidepup", 
16904              None, [cty.c_int], 
16905              """void fl_hidepup(int n) 
16906              """) 
16907      ipopupid = convert_to_int(popupid) 
16908      keep_elem_refs(popupid, ipopupid) 
16909      _fl_hidepup(ipopupid) 
16910   
16911   
16912 -def fl_getpup_items(popupid): 
16913      """ 
16914          fl_getpup_items(popupid) -> num. 
16915      """ 
16916   
16917      _fl_getpup_items = cfuncproto( 
16918              load_so_libforms(), "fl_getpup_items", 
16919              cty.c_int, [cty.c_int], 
16920              """int fl_getpup_items(int n) 
16921              """) 
16922      ipopupid = convert_to_int(popupid) 
16923      keep_elem_refs(popupid, ipopupid) 
16924      retval = _fl_getpup_items(ipopupid) 
16925      return retval 
16926   
16927   
16928 -def fl_current_pup(): 
16929      """ 
16930          fl_current_pup() -> num. 
16931      """ 
16932   
16933      _fl_current_pup = cfuncproto( 
16934              load_so_libforms(), "fl_current_pup", 
16935              cty.c_int, [], 
16936              """int fl_current_pup() 
16937              """) 
16938      retval = _fl_current_pup() 
16939      return retval 
16940   
16941   
16942 -def fl_setpup_itemcb(popupid, itemval, py_PupCb): 
16943      """ 
16944          fl_setpup_itemcb(popupid, itemval, py_PupCb) -> pup_cb 
16945      """ 
16946   
16947      _fl_setpup_itemcb = cfuncproto( 
16948              load_so_libforms(), "fl_setpup_itemcb", 
16949              FL_PUP_CB, [cty.c_int, cty.c_int, FL_PUP_CB], 
16950              """FL_PUP_CB fl_setpup_itemcb(int nm, int ni, FL_PUP_CB cb) 
16951              """) 
16952      ipopupid = convert_to_int(popupid) 
16953      iitemval = convert_to_int(itemval) 
16954      c_PupCb = FL_PUP_CB(py_PupCb) 
16955      keep_cfunc_refs(c_PupCb, py_PupCb) 
16956      keep_elem_refs(popupid, itemval, ipopupid, iitemval) 
16957      retval = _fl_setpup_itemcb(ipopupid, iitemval, c_PupCb) 
16958      return retval 
16959   
16960   
16961 -def fl_setpup_menucb(popupid, py_PupCb): 
16962      """ fl_setpup_menucb(popupid, py_PupCb) -> pup_cb func. 
16963      """ 
16964   
16965      _fl_setpup_menucb = cfuncproto( 
16966              load_so_libforms(), "fl_setpup_menucb", 
16967              FL_PUP_CB, [cty.c_int, FL_PUP_CB], 
16968              """FL_PUP_CB fl_setpup_menucb(int nm, FL_PUP_CB cb) 
16969              """) 
16970      ipopupid = convert_to_int(popupid) 
16971      c_PupCb = FL_PUP_CB(py_PupCb) 
16972      keep_cfunc_refs(c_PupCb, py_PupCb) 
16973      keep_elem_refs(popupid, ipopupid) 
16974      retval = _fl_setpup_menucb(ipopupid, c_PupCb) 
16975      return retval 
16976   
16977   
16978 -def fl_setpup_submenu(popupid, itemval, subpopupid): 
16979      """ 
16980          fl_setpup_submenu(popupid, itemval, subpopupid) 
16981      """ 
16982   
16983      _fl_setpup_submenu = cfuncproto( 
16984              load_so_libforms(), "fl_setpup_submenu", 
16985              None, [cty.c_int, cty.c_int, cty.c_int], 
16986              """void fl_setpup_submenu(int m, int i, int subm) 
16987              """) 
16988      ipopupid = convert_to_int(popupid) 
16989      iitemval = convert_to_int(itemval) 
16990      isubpopupid = convert_to_int(subpopupid) 
16991      keep_elem_refs(popupid, itemval, subpopupid, ipopupid, iitemval, \ 
16992                     isubpopupid) 
16993      _fl_setpup_submenu(ipopupid, iitemval, isubpopupid) 
16994   
16995   
16996  fl_setpup = fl_setpup_mode 
16997   
16998   
16999  # Others 
17000   
17001 -def fl_create_xyplot(plottype, x, y, w, h, label): 
17002      """ 
17003          fl_create_xyplot(plottype, x, y, w, h, label) -> pObject 
17004      """ 
17005   
17006      _fl_create_xyplot = cfuncproto( 
17007              load_so_libforms(), "fl_create_xyplot", 
17008              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
17009              FL_Coord, STRING], 
17010              """FL_OBJECT * fl_create_xyplot(int t, FL_Coord x, FL_Coord y, 
17011                 FL_Coord w, FL_Coord h, const char * label) 
17012              """) 
17013      check_admitted_listvalues(plottype, XYPLOTTYPE_list) 
17014      iplottype = convert_to_int(plottype) 
17015      ix = convert_to_FL_Coord(x) 
17016      iy = convert_to_FL_Coord(y) 
17017      iw = convert_to_FL_Coord(w) 
17018      ih = convert_to_FL_Coord(h) 
17019      slabel = convert_to_string(label) 
17020      keep_elem_refs(plottype, x, y, w, h, label, iplottype, ix, iy, 
17021                     iw, ih, slabel) 
17022      retval = _fl_create_xyplot(iplottype, ix, iy, iw, ih, slabel) 
17023      return retval 
17024   
17025   
17026 -def fl_add_xyplot(plottype, x, y, w, h, label): 
17027      """ 
17028          fl_add_xyplot(plottype, x, y, w, h, label) -> pObject 
17029      """ 
17030   
17031      _fl_add_xyplot = cfuncproto( 
17032              load_so_libforms(), "fl_add_xyplot", 
17033              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
17034              FL_Coord, STRING], 
17035              """FL_OBJECT * fl_add_xyplot(int t, FL_Coord x, FL_Coord y, 
17036                 FL_Coord w, FL_Coord h, const char * label) 
17037              """) 
17038      check_admitted_listvalues(plottype, XYPLOTTYPE_list) 
17039      iplottype = convert_to_int(plottype) 
17040      ix = convert_to_FL_Coord(x) 
17041      iy = convert_to_FL_Coord(y) 
17042      iw = convert_to_FL_Coord(w) 
17043      ih = convert_to_FL_Coord(h) 
17044      slabel = convert_to_string(label) 
17045      keep_elem_refs(plottype, x, y, w, h, label, iplottype, ix, iy, 
17046                     iw, ih, slabel) 
17047      retval = _fl_add_xyplot(iplottype, ix, iy, iw, ih, slabel) 
17048      return retval 
17049   
17050   
17051 -def fl_set_xyplot_data(pObject, xlist, ylist, n, title, xlabel, ylabel): 
17052      """ fl_set_xyplot_data(pObject, xlist, ylist, n, title, xlabel, ylabel) 
17053   
17054      @param pObject : pointer to object 
17055      """ 
17056   
17057      _fl_set_xyplot_data = cfuncproto( 
17058              load_so_libforms(), "fl_set_xyplot_data", 
17059              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17060              cty.POINTER(cty.c_float), cty.c_int, STRING, STRING, STRING], 
17061              """void fl_set_xyplot_data(FL_OBJECT * ob, float * x, float * y, 
17062                 int n, const char * title, const char * xlabel, 
17063                 const char * ylabel) 
17064              """) 
17065      #px = cty.cast(x, cty.POINTER(cty.c_float)) 
17066      print xlist, xlist[0] 
17067      fx = [] 
17068      for a in range(xlist): 
17069          fx[a] = convert_to_float(xlist[a]) 
17070      px = cty.pointer(fx) 
17071      print "x, fx, px", xlist, fx, px 
17072      #py = cty.cast(y, cty.POINTER(cty.c_float)) 
17073      fy = [] 
17074      for a in range(ylist): 
17075          fy[a] = convert_to_float(ylist[a]) 
17076      py = cty.pointer(fy) 
17077      print "y, fy, py", ylist, fy, py 
17078      inum = convert_to_int(n) 
17079      stitle = convert_to_string(title) 
17080      sxlabel = convert_to_string(xlabel) 
17081      sylabel = convert_to_string(ylabel) 
17082      keep_elem_refs(pObject, xlist, ylist, n, fx, fy, px, py, title, \ 
17083                     xlabel, ylabel, inum, stitle, sxlabel, sylabel) 
17084      _fl_set_xyplot_data(pObject, px, py, inum, stitle, sxlabel, sylabel) 
17085   
17086   
17087 -def fl_set_xyplot_data_double(pObject, x, y, n, title, xlabel, ylabel): 
17088      """ fl_set_xyplot_data_double(pObject, x, y, n, title, xlabel, ylabel) 
17089   
17090      @param pObject : pointer to object 
17091      """ 
17092   
17093      _fl_set_xyplot_data_double = cfuncproto( 
17094              load_so_libforms(), "fl_set_xyplot_data_double", 
17095              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
17096              cty.POINTER(cty.c_double), cty.c_int, STRING, STRING, STRING], 
17097              """void fl_set_xyplot_data_double(FL_OBJECT * ob, double * x, 
17098                 double * y, int n, const char * title, const char * xlabel, 
17099                 const char * ylabel) 
17100              """) 
17101      px = cty.cast(x, cty.POINTER(cty.c_double)) 
17102      py = cty.cast(y, cty.POINTER(cty.c_double)) 
17103      inum = convert_to_int(n) 
17104      stitle = convert_to_string(title) 
17105      sxlabel = convert_to_string(xlabel) 
17106      sylabel = convert_to_string(ylabel) 
17107      keep_elem_refs(pObject, x, y, n, title, xlabel, ylabel, px, py, inum, \ 
17108                     stitle, sxlabel, sylabel) 
17109      _fl_set_xyplot_data_double(pObject, px, py, n, title, \ 
17110                                          xlabel, ylabel, inum, stitle, \ 
17111                                          sxlabel, sylabel) 
17112   
17113   
17114 -def fl_set_xyplot_file(pObject, f, title, xl, yl): 
17115      """ fl_set_xyplot_file(pObject, f, title, xl, yl) -> num. 
17116   
17117      @param pObject : pointer to object 
17118      """ 
17119   
17120      _fl_set_xyplot_file = cfuncproto( 
17121              load_so_libforms(), "fl_set_xyplot_file", 
17122              cty.c_int, [cty.POINTER(FL_OBJECT), STRING, STRING, STRING, 
17123              STRING], 
17124              """int fl_set_xyplot_file(FL_OBJECT * ob, const char * f, 
17125                 const char * title, const char * xl, const char * yl) 
17126              """) 
17127      sf = convert_to_string(f) 
17128      stitle = convert_to_string(title) 
17129      sxl = convert_to_string(xl) 
17130      syl = convert_to_string(yl) 
17131      keep_elem_refs(pObject, f, title, xl, yl, sf, stitle, sxl, syl) 
17132      retval = _fl_set_xyplot_file(pObject, sf, stitle, sxl, syl) 
17133      return retval 
17134   
17135   
17136 -def fl_insert_xyplot_data(pObject, idnum, n, valx, valy): 
17137      """ fl_insert_xyplot_data(pObject, idnum, n, valx, valy) 
17138   
17139      @param pObject : pointer to object 
17140      """ 
17141   
17142      _fl_insert_xyplot_data = cfuncproto( 
17143              load_so_libforms(), "fl_insert_xyplot_data", 
17144              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, cty.c_double, 
17145              cty.c_double], 
17146              """void fl_insert_xyplot_data(FL_OBJECT * ob, int id, int n, 
17147                 double x, double y) 
17148              """) 
17149      iidnum = convert_to_int(idnum) 
17150      inum = convert_to_int(n) 
17151      fvalx = convert_to_double(valx) 
17152      fvaly = convert_to_double(valy) 
17153      keep_elem_refs(pObject, idnum, n, valx, valy, iidnum, inum, fvalx, fvaly) 
17154      _fl_insert_xyplot_data(pObject, iidnum, inum, fvalx, fvaly) 
17155   
17156   
17157 -def fl_add_xyplot_text(pObject, valx, valy, text, al, colr): 
17158      """ fl_add_xyplot_text(pObject, valx, valy, text, al, colr) 
17159   
17160      @param pObject : pointer to object 
17161      """ 
17162   
17163      _fl_add_xyplot_text = cfuncproto( 
17164              load_so_libforms(), "fl_add_xyplot_text", 
17165              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double, STRING, 
17166              cty.c_int, FL_COLOR], 
17167              """void fl_add_xyplot_text(FL_OBJECT * ob, double x, double y, 
17168                 const char * text, int al, FL_COLOR col) 
17169              """) 
17170      fvalx = convert_to_double(valx) 
17171      fvaly = convert_to_double(valy) 
17172      stext = convert_to_string(text) 
17173      ial = convert_to_int(al) 
17174      ulcolr = convert_to_FL_COLOR(colr) 
17175      keep_elem_refs(pObject, valx, valy, text, al, colr, fvalx, fvaly, \ 
17176                     stext, ial, ulcolr) 
17177      _fl_add_xyplot_text(pObject, fvalx, fvaly, stext, ial, ulcolr) 
17178   
17179   
17180 -def fl_delete_xyplot_text(pObject, text): 
17181      """ fl_delete_xyplot_text(pObject, text) 
17182   
17183      @param pObject : pointer to object 
17184      """ 
17185   
17186      _fl_delete_xyplot_text = cfuncproto( 
17187              load_so_libforms(), "fl_delete_xyplot_text", 
17188              None, [cty.POINTER(FL_OBJECT), STRING], 
17189              """void fl_delete_xyplot_text(FL_OBJECT * ob, const char * text) 
17190              """) 
17191      stext = convert_to_string(text) 
17192      keep_elem_refs(pObject, text, stext) 
17193      _fl_delete_xyplot_text(pObject, stext) 
17194   
17195   
17196 -def fl_set_xyplot_maxoverlays(pObject, maxover): 
17197      """ fl_set_xyplot_maxoverlays(pObject, maxover) -> num. 
17198   
17199      @param pObject : pointer to object 
17200      """ 
17201   
17202      _fl_set_xyplot_maxoverlays = cfuncproto( 
17203              load_so_libforms(), "fl_set_xyplot_maxoverlays", 
17204              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
17205              """int fl_set_xyplot_maxoverlays(FL_OBJECT * ob, int maxover) 
17206              """) 
17207      imaxover = convert_to_int(maxover) 
17208      keep_elem_refs(pObject, maxover, imaxover) 
17209      retval = _fl_set_xyplot_maxoverlays(pObject, imaxover) 
17210      return retval 
17211   
17212   
17213 -def fl_add_xyplot_overlay(pObject, idnum, x, y, n, colr): 
17214      """ fl_add_xyplot_overlay(pObject, idnum, x, y, n, colr) 
17215   
17216      @param pObject : pointer to object 
17217      """ 
17218   
17219      _fl_add_xyplot_overlay = cfuncproto( 
17220              load_so_libforms(), "fl_add_xyplot_overlay", 
17221              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.POINTER(cty.c_float), 
17222              cty.POINTER(cty.c_float), cty.c_int, FL_COLOR], 
17223              """void fl_add_xyplot_overlay(FL_OBJECT * ob, int id, float * x, 
17224                 float * y, int n, FL_COLOR col) 
17225              """) 
17226      iidnum = convert_to_int(idnum) 
17227      px = cty.cast(x, cty.POINTER(cty.c_float)) 
17228      py = cty.cast(y, cty.POINTER(cty.c_float)) 
17229      inum = convert_to_int(n) 
17230      ulcolr = convert_to_FL_COLOR(colr) 
17231      keep_elem_refs(pObject, idnum, x, y, n, colr, iidnum, px, py, inum, \ 
17232                     ulcolr) 
17233      _fl_add_xyplot_overlay(pObject, iidnum, px, py, inum, ulcolr) 
17234   
17235   
17236 -def fl_add_xyplot_overlay_file(pObject, idnum, f, colr): 
17237      """ fl_add_xyplot_overlay_file(pObject, idnum, f, colr) -> num. 
17238   
17239      @param pObject : pointer to object 
17240      """ 
17241   
17242      _fl_add_xyplot_overlay_file = cfuncproto( 
17243              load_so_libforms(), "fl_add_xyplot_overlay_file", 
17244              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, STRING, FL_COLOR], 
17245              """int fl_add_xyplot_overlay_file(FL_OBJECT * ob, int id, 
17246              const char * f, FL_COLOR c) 
17247              """) 
17248      iidnum = convert_to_int(idnum) 
17249      sf = convert_to_string(f) 
17250      ulcolr = convert_to_FL_COLOR(colr) 
17251      keep_elem_refs(pObject, idnum, f, colr, iidnum, sf, ulcolr) 
17252      retval = _fl_add_xyplot_overlay_file(pObject, iidnum, sf, ulcolr) 
17253      return retval 
17254   
17255   
17256 -def fl_set_xyplot_return(pObject, when): 
17257      """ fl_set_xyplot_return(pObject, when) 
17258   
17259      @param pObject : pointer to object 
17260      """ 
17261   
17262      _fl_set_xyplot_return = cfuncproto( 
17263              load_so_libforms(), "fl_set_xyplot_return", 
17264              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17265              """void fl_set_xyplot_return(FL_OBJECT * ob, int when) 
17266              """) 
17267      iwhen = convert_to_int(when) 
17268      keep_elem_refs(pObject, when, iwhen) 
17269      _fl_set_xyplot_return(pObject, iwhen) 
17270   
17271   
17272 -def fl_set_xyplot_xtics(pObject, major, minor): 
17273      """ fl_set_xyplot_xtics(pObject, major, minor) 
17274   
17275      @param pObject : pointer to object 
17276      """ 
17277   
17278      _fl_set_xyplot_xtics = cfuncproto( 
17279              load_so_libforms(), "fl_set_xyplot_xtics", 
17280              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
17281              """void fl_set_xyplot_xtics(FL_OBJECT * ob, int major, int minor) 
17282              """) 
17283      imajor = convert_to_int(major) 
17284      iminor = convert_to_int(minor) 
17285      keep_elem_refs(pObject, major, minor, imajor, iminor) 
17286      _fl_set_xyplot_xtics(pObject, imajor, iminor) 
17287   
17288   
17289 -def fl_set_xyplot_ytics(pObject, major, minor): 
17290      """ fl_set_xyplot_ytics(pObject, major, minor) 
17291   
17292      @param pObject : pointer to object 
17293      """ 
17294   
17295      _fl_set_xyplot_ytics = cfuncproto( 
17296              load_so_libforms(), "fl_set_xyplot_ytics", 
17297              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
17298              """void fl_set_xyplot_ytics(FL_OBJECT * ob, int major, int minor) 
17299              """) 
17300      imajor = convert_to_int(major) 
17301      iminor = convert_to_int(minor) 
17302      keep_elem_refs(pObject, major, minor, imajor, iminor) 
17303      _fl_set_xyplot_ytics(pObject, imajor, iminor) 
17304   
17305   
17306 -def fl_set_xyplot_xbounds(pObject, minbound, maxbound): 
17307      """ fl_set_xyplot_xbounds(pObject, minbound, maxbound) 
17308   
17309      @param pObject : pointer to object 
17310      """ 
17311   
17312      _fl_set_xyplot_xbounds = cfuncproto( 
17313              load_so_libforms(), "fl_set_xyplot_xbounds", 
17314              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
17315              """void fl_set_xyplot_xbounds(FL_OBJECT * ob, double xmin, 
17316                 double xmax) 
17317              """) 
17318      fminbound = convert_to_double(minbound) 
17319      fmaxbound = convert_to_double(maxbound) 
17320      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
17321      _fl_set_xyplot_xbounds(pObject, fminbound, fmaxbound) 
17322   
17323   
17324 -def fl_set_xyplot_ybounds(pObject, minbound, maxbound): 
17325      """ fl_set_xyplot_ybounds(pObject, minbound, maxbound) 
17326   
17327      @param pObject : pointer to object 
17328      """ 
17329   
17330      _fl_set_xyplot_ybounds = cfuncproto( 
17331              load_so_libforms(), "fl_set_xyplot_ybounds", 
17332              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
17333              """void fl_set_xyplot_ybounds(FL_OBJECT * ob, double ymin, 
17334                 double ymax) 
17335              """) 
17336      fminbound = convert_to_double(minbound) 
17337      fmaxbound = convert_to_double(maxbound) 
17338      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
17339      _fl_set_xyplot_ybounds(pObject, fminbound, fmaxbound) 
17340   
17341   
17342  #def fl_get_xyplot_xbounds(pObject, minbound, maxbound)       *API change* 
17343 -def fl_get_xyplot_xbounds(pObject): 
17344      """ fl_get_xyplot_xbounds(pObject) -> minbound, maxbound 
17345   
17346      @param pObject : pointer to object 
17347      """ 
17348   
17349      _fl_get_xyplot_xbounds = cfuncproto( 
17350              load_so_libforms(), "fl_get_xyplot_xbounds", 
17351              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17352              cty.POINTER(cty.c_float)], 
17353              """void fl_get_xyplot_xbounds(FL_OBJECT * ob, float * xmin, 
17354                 float * xmax) 
17355              """) 
17356      minbound, pminbound = make_float_and_pointer() 
17357      maxbound, pmaxbound = make_float_and_pointer() 
17358      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
17359      _fl_get_xyplot_xbounds(pObject, pminbound, pmaxbound) 
17360      return minbound, maxbound 
17361   
17362   
17363  #def fl_get_xyplot_ybounds(pObject, minbound, maxbound)       *API change* 
17364 -def fl_get_xyplot_ybounds(pObject): 
17365      """ fl_get_xyplot_ybounds(pObject) -> minbound, maxbound 
17366   
17367      @param pObject : pointer to object 
17368      """ 
17369   
17370      _fl_get_xyplot_ybounds = cfuncproto( 
17371              load_so_libforms(), "fl_get_xyplot_ybounds", 
17372              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17373              cty.POINTER(cty.c_float)], 
17374              """void fl_get_xyplot_ybounds(FL_OBJECT * ob, float * ymin, 
17375                 float * ymax) 
17376              """) 
17377      minbound, pminbound = make_float_and_pointer() 
17378      maxbound, pmaxbound = make_float_and_pointer() 
17379      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
17380      _fl_get_xyplot_ybounds(pObject, pminbound, pmaxbound) 
17381      return minbound, maxbound 
17382   
17383   
17384  #def fl_get_xyplot(pObject, x, y, i)       *API change* 
17385 -def fl_get_xyplot(pObject): 
17386      """ 
17387          fl_get_xyplot(pObject) -> x, y, i 
17388   
17389          @param pObject : pointer to object 
17390      """ 
17391   
17392      _fl_get_xyplot = cfuncproto( 
17393              load_so_libforms(), "fl_get_xyplot", 
17394              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17395              cty.POINTER(cty.c_float), cty.POINTER(cty.c_int)], 
17396              """void fl_get_xyplot(FL_OBJECT * ob, float * x, float * y, 
17397                 int * i) 
17398              """) 
17399      x, px = make_float_and_pointer() 
17400      y, py = make_float_and_pointer() 
17401      i, pi = make_int_and_pointer() 
17402      keep_elem_refs(pObject, x, y, i, px, py, pi) 
17403      _fl_get_xyplot(pObject, px, py, pi) 
17404      return x, y, i 
17405   
17406   
17407  #def fl_get_xyplot_data(pObject, x, y, n)       *API change* 
17408 -def fl_get_xyplot_data(pObject): 
17409      """ fl_get_xyplot_data(pObject) -> x, y, n 
17410   
17411      @param pObject : pointer to object 
17412      """ 
17413   
17414      _fl_get_xyplot_data = cfuncproto( 
17415              load_so_libforms(), "fl_get_xyplot_data", 
17416              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17417              cty.POINTER(cty.c_float), cty.POINTER(cty.c_int)], 
17418              """void fl_get_xyplot_data(FL_OBJECT * ob, float * x, float * y, 
17419                 int * n) 
17420              """) 
17421      x, px = make_float_and_pointer() 
17422      y, py = make_float_and_pointer() 
17423      n, pn = make_int_and_pointer() 
17424      keep_elem_refs(pObject, x, y, n, px, py, pn) 
17425      _fl_get_xyplot_data(pObject, px, py, pn) 
17426      return x, y, n 
17427   
17428   
17429  #def fl_get_xyplot_data_pointer(pObject, idnum, x, y, n)       *API change* 
17430 -def fl_get_xyplot_data_pointer(pObject, idnum): 
17431      """ fl_get_xyplot_data_pointer(pObject, idnum) -> x, y, n 
17432   
17433      @param pObject : pointer to object 
17434      """ 
17435   
17436      _fl_get_xyplot_data_pointer = cfuncproto( 
17437              load_so_libforms(), "fl_get_xyplot_data_pointer", 
17438              None, [cty.POINTER(FL_OBJECT), cty.c_int, 
17439              cty.POINTER(cty.POINTER(cty.c_float)), 
17440              cty.POINTER(cty.POINTER(cty.c_float)), cty.POINTER(cty.c_int)], 
17441              """void fl_get_xyplot_data_cty.POINTER(FL_OBJECT * ob, int id, 
17442                 float * * x, float * * y, int * n) 
17443              """) 
17444      iidnum = convert_to_int(idnum) 
17445      x, px = make_float_and_pointer() 
17446      y, py = make_float_and_pointer() 
17447      n, pn = make_int_and_pointer() 
17448      keep_elem_refs(pObject, idnum, iidnum, x, y, n, px, py, pn) 
17449      _fl_get_xyplot_data_pointer(pObject, iidnum, px, py, pn) 
17450      return x, y, n 
17451   
17452   
17453  #def fl_get_xyplot_overlay_data(pObject, idnum, x, y, n)       *API change* 
17454 -def fl_get_xyplot_overlay_data(pObject, idnum): 
17455      """ fl_get_xyplot_overlay_data(pObject, idnum) -> x, y, n 
17456   
17457      @param pObject : pointer to object 
17458      """ 
17459   
17460      _fl_get_xyplot_overlay_data = cfuncproto( 
17461              load_so_libforms(), "fl_get_xyplot_overlay_data", 
17462              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.POINTER(cty.c_float), 
17463              cty.POINTER(cty.c_float), cty.POINTER(cty.c_int)], 
17464              """void fl_get_xyplot_overlay_data(FL_OBJECT * ob, int id, 
17465                 float * x, float * y, int * n) 
17466              """) 
17467      iidnum = convert_to_int(idnum) 
17468      x, px = make_float_and_pointer() 
17469      y, py = make_float_and_pointer() 
17470      n, pn = make_int_and_pointer() 
17471      keep_elem_refs(pObject, idnum, iidnum, x, y, n, px, py, pn) 
17472      _fl_get_xyplot_overlay_data(pObject, iidnum, px, py, pn) 
17473      return x, y, n 
17474   
17475   
17476 -def fl_set_xyplot_overlay_type(pObject, idnum, plottype): 
17477      """ fl_set_xyplot_overlay_type(pObject, idnum, plottype) 
17478   
17479      @param pObject : pointer to object 
17480      """ 
17481   
17482      _fl_set_xyplot_overlay_type = cfuncproto( 
17483              load_so_libforms(), "fl_set_xyplot_overlay_type", 
17484              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
17485              """void fl_set_xyplot_overlay_type(FL_OBJECT * ob, int id, 
17486                 int type) 
17487              """) 
17488      iidnum = convert_to_int(idnum) 
17489      iplottype = convert_to_int(plottype) 
17490      keep_elem_refs(pObject, idnum, plottype, iidnum, iplottype) 
17491      _fl_set_xyplot_overlay_type(pObject, iidnum, iplottype) 
17492   
17493   
17494 -def fl_delete_xyplot_overlay(pObject, idnum): 
17495      """ fl_delete_xyplot_overlay(pObject, idnum) 
17496   
17497      @param pObject : pointer to object 
17498      """ 
17499   
17500      _fl_delete_xyplot_overlay = cfuncproto( 
17501              load_so_libforms(), "fl_delete_xyplot_overlay", 
17502              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17503              """void fl_delete_xyplot_overlay(FL_OBJECT * ob, int id) 
17504              """) 
17505      iidnum = convert_to_int(idnum) 
17506      keep_elem_refs(pObject, idnum, iidnum) 
17507      _fl_delete_xyplot_overlay(pObject, iidnum) 
17508   
17509   
17510 -def fl_set_xyplot_interpolate(pObject, idnum, deg, grid): 
17511      """ 
17512          fl_set_xyplot_interpolate(pObject, idnum, deg, grid) 
17513   
17514          @param pObject : pointer to object 
17515      """ 
17516   
17517      _fl_set_xyplot_interpolate = cfuncproto( 
17518              load_so_libforms(), "fl_set_xyplot_interpolate", 
17519              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, 
17520              cty.c_double], 
17521              """void fl_set_xyplot_interpolate(FL_OBJECT * ob, int id, 
17522                 int deg, double grid) 
17523              """) 
17524      iidnum = convert_to_int(idnum) 
17525      ideg = convert_to_int(deg) 
17526      fgrid = convert_to_double(grid) 
17527      keep_elem_refs(pObject, idnum, deg, grid, iidnum, ideg, fgrid) 
17528      _fl_set_xyplot_interpolate(pObject, iidnum, ideg, fgrid) 
17529   
17530   
17531 -def fl_set_xyplot_inspect(pObject, yes): 
17532      """ 
17533          fl_set_xyplot_inspect(pObject, yes) 
17534   
17535          @param pObject : pointer to object 
17536      """ 
17537   
17538      _fl_set_xyplot_inspect = cfuncproto( 
17539              load_so_libforms(), "fl_set_xyplot_inspect", 
17540              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17541              """void fl_set_xyplot_inspect(FL_OBJECT * ob, int yes) 
17542              """) 
17543      iyes = convert_to_int(yes) 
17544      keep_elem_refs(pObject, yes, iyes) 
17545      _fl_set_xyplot_inspect(pObject, iyes) 
17546   
17547   
17548 -def fl_set_xyplot_symbolsize(pObject, n): 
17549      """ 
17550          fl_set_xyplot_symbolsize(pObject, n) 
17551   
17552          @param pObject : pointer to object 
17553      """ 
17554   
17555      _fl_set_xyplot_symbolsize = cfuncproto( 
17556              load_so_libforms(), "fl_set_xyplot_symbolsize", 
17557              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17558              """void fl_set_xyplot_symbolsize(FL_OBJECT * ob, int n) 
17559              """) 
17560      inum = convert_to_int(n) 
17561      keep_elem_refs(pObject, n, inum) 
17562      _fl_set_xyplot_symbolsize(pObject, inum) 
17563   
17564   
17565 -def fl_replace_xyplot_point(pObject, i, valx, valy): 
17566      """ 
17567          fl_replace_xyplot_point(pObject, i, valx, valy) 
17568   
17569          @param pObject : pointer to object 
17570      """ 
17571   
17572      _fl_replace_xyplot_point = cfuncproto( 
17573              load_so_libforms(), "fl_replace_xyplot_point", 
17574              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double, 
17575              cty.c_double], 
17576              """void fl_replace_xyplot_point(FL_OBJECT * ob, int i, 
17577                 double x, double y) 
17578              """) 
17579      ii = convert_to_int(i) 
17580      fvalx = convert_to_double(valx) 
17581      fvaly = convert_to_double(valy) 
17582      keep_elem_refs(pObject, i, valx, valy, ii, fvalx, fvaly) 
17583      _fl_replace_xyplot_point(pObject, ii, fvalx, fvaly) 
17584   
17585   
17586  # Replace the value of a particular point in dataset setID, 
17587  # where setID=0 is the first data set. 
17588  # This routine is an extension of fl_replace_xyplot_point 
17589  # which acts on the first dataset only. 
17590   
17591 -def fl_replace_xyplot_point_in_overlay(pObject, i, setID, valx, valy): 
17592      """ 
17593          fl_replace_xyplot_point_in_overlay(pObject, i, setID, valx, valy) 
17594   
17595          @param pObject : pointer to object 
17596      """ 
17597   
17598      _fl_replace_xyplot_point_in_overlay = cfuncproto( 
17599              load_so_libforms(), "fl_replace_xyplot_point_in_overlay", 
17600              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, \ 
17601              cty.c_double, cty.c_double], 
17602              """void fl_replace_xyplot_point_in_overlay(FL_OBJECT * ob, 
17603                 int i, int setID, double x, double y) 
17604              """) 
17605      ii = convert_to_int(i) 
17606      isetID = convert_to_int(setID) 
17607      fvalx = convert_to_double(valx) 
17608      fvaly = convert_to_double(valy) 
17609      keep_elem_refs(pObject, i, setID, valx, valy, ii, isetID, fvalx, fvaly) 
17610      _fl_replace_xyplot_point_in_overlay(pObject, ii, isetID, fvalx, fvaly) 
17611   
17612   
17613  #def fl_get_xyplot_xmapping(pObject, a, b)       *API change* 
17614 -def fl_get_xyplot_xmapping(pObject): 
17615      """ 
17616          fl_get_xyplot_xmapping(pObject) -> a, b 
17617   
17618          @param pObject : pointer to object 
17619      """ 
17620   
17621      _fl_get_xyplot_xmapping = cfuncproto( 
17622              load_so_libforms(), "fl_get_xyplot_xmapping", 
17623              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17624              cty.POINTER(cty.c_float)], 
17625              """void fl_get_xyplot_xmapping(FL_OBJECT * ob, float * a, 
17626                 float * b) 
17627              """) 
17628      a, pa = make_float_and_pointer() 
17629      b, pb = make_float_and_pointer() 
17630      keep_elem_refs(pObject, a, b, pa, pb) 
17631      _fl_get_xyplot_xmapping(pObject, pa, pb) 
17632      return a, b 
17633   
17634   
17635  #def fl_get_xyplot_ymapping(pObject, a, b)       *API change* 
17636 -def fl_get_xyplot_ymapping(pObject): 
17637      """ 
17638          fl_get_xyplot_ymapping(pObject) -> a, b 
17639   
17640          @param pObject : pointer to object 
17641      """ 
17642   
17643      _fl_get_xyplot_ymapping = cfuncproto( 
17644              load_so_libforms(), "fl_get_xyplot_ymapping", 
17645              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17646              cty.POINTER(cty.c_float)], 
17647              """void fl_get_xyplot_ymapping(FL_OBJECT * ob, float * a, 
17648                 float * b) 
17649              """) 
17650      a, pa = make_float_and_pointer() 
17651      b, pb = make_float_and_pointer() 
17652      keep_elem_refs(pObject, a, b, pa, pb) 
17653      _fl_get_xyplot_ymapping(pObject, pa, pb) 
17654      return a, b 
17655   
17656   
17657 -def fl_set_xyplot_keys(pObject, keys, valx, valy, align): 
17658      """ 
17659          fl_set_xyplot_keys(pObject, keys, valx, valy, align) 
17660   
17661          @param pObject : pointer to object 
17662      """ 
17663   
17664      _fl_set_xyplot_keys = cfuncproto( 
17665              load_so_libforms(), "fl_set_xyplot_keys", 
17666              None, [cty.POINTER(FL_OBJECT), cty.POINTER(STRING), cty.c_float, 
17667              cty.c_float, cty.c_int], 
17668              """void fl_set_xyplot_keys(FL_OBJECT * ob, char * * keys, float x, 
17669                 float y, int align) 
17670              """) 
17671      fvalx = convert_to_float(valx) 
17672      fvaly = convert_to_float(valy) 
17673      ialign = convert_to_int(align) 
17674      keep_elem_refs(pObject, keys, valx, valy, align, fvalx, fvaly, ialign) 
17675      _fl_set_xyplot_keys(pObject, keys, fvalx, fvaly, ialign) 
17676   
17677   
17678 -def fl_set_xyplot_key(pObject, idnum, keytxt): 
17679      """ 
17680          fl_set_xyplot_key(pObject, idnum, keytxt) 
17681   
17682          @param pObject : pointer to object 
17683      """ 
17684   
17685      _fl_set_xyplot_key = cfuncproto( 
17686              load_so_libforms(), "fl_set_xyplot_key", 
17687              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
17688              """void fl_set_xyplot_key(FL_OBJECT * ob, int id, 
17689                 const char * key) 
17690              """) 
17691      iidnum = convert_to_int(idnum) 
17692      skeytxt = convert_to_string(keytxt) 
17693      keep_elem_refs(pObject, idnum, keytxt, iidnum, skeytxt) 
17694      _fl_set_xyplot_key(pObject, iidnum, skeytxt) 
17695   
17696   
17697 -def fl_set_xyplot_key_position(pObject, valx, valy, align): 
17698      """ 
17699          fl_set_xyplot_key_position(pObject, valx, valy, align) 
17700   
17701          @param pObject : pointer to object 
17702      """ 
17703   
17704      _fl_set_xyplot_key_position = cfuncproto( 
17705              load_so_libforms(), "fl_set_xyplot_key_position", 
17706              None, [cty.POINTER(FL_OBJECT), cty.c_float, cty.c_float, 
17707              cty.c_int], 
17708              """void fl_set_xyplot_key_position(FL_OBJECT * ob, float x, 
17709                 float y, int align) 
17710              """) 
17711      fvalx = convert_to_float(valx) 
17712      fvaly = convert_to_float(valy) 
17713      ialign = convert_to_int(align) 
17714      keep_elem_refs(pObject, valx, valy, align, fvalx, fvaly, ialign) 
17715      _fl_set_xyplot_key_position(pObject, fvalx, fvaly, ialign) 
17716   
17717   
17718 -def fl_set_xyplot_key_font(pObject, style, size): 
17719      """ 
17720          fl_set_xyplot_key_font(pObject, style, size) 
17721   
17722          @param pObject : pointer to object 
17723      """ 
17724   
17725      _fl_set_xyplot_key_font = cfuncproto( 
17726              load_so_libforms(), "fl_set_xyplot_key_font", 
17727              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
17728              """void fl_set_xyplot_key_font(FL_OBJECT * ob, int style, 
17729                 int size) 
17730              """) 
17731      istyle = convert_to_int(style) 
17732      isize = convert_to_int(size) 
17733      keep_elem_refs(pObject, style, size, istyle, isize) 
17734      _fl_set_xyplot_key_font(pObject, istyle, isize) 
17735   
17736   
17737 -def fl_get_xyplot_numdata(pObject, idnum): 
17738      """ 
17739          fl_get_xyplot_numdata(pObject, idnum) -> num. 
17740   
17741          @param pObject : pointer to object 
17742      """ 
17743   
17744      _fl_get_xyplot_numdata = cfuncproto( 
17745              load_so_libforms(), "fl_get_xyplot_numdata", 
17746              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
17747              """int fl_get_xyplot_numdata(FL_OBJECT * ob, int id) 
17748              """) 
17749      iidnum = convert_to_int(idnum) 
17750      keep_elem_refs(pObject, idnum, iidnum) 
17751      retval = _fl_get_xyplot_numdata(pObject, iidnum) 
17752      return retval 
17753   
17754   
17755  # The following two functions will be removed. 
17756  # Use fl_set_object_l[size|style] for the functionalities 
17757   
17758 -def fl_set_xyplot_fontsize(pObject, size): 
17759      """ 
17760          fl_set_xyplot_fontsize(pObject, size) 
17761   
17762          @param pObject : pointer to object 
17763      """ 
17764   
17765      _fl_set_xyplot_fontsize = cfuncproto( 
17766              load_so_libforms(), "fl_set_xyplot_fontsize", 
17767              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17768              """void fl_set_xyplot_fontsize(FL_OBJECT * ob, int size) DEPRECATED 
17769              """) 
17770      warn_deprecated_function("Use fl_set_lsize, instead.") 
17771      isize = convert_to_int(size) 
17772      keep_elem_refs(pObject, size, isize) 
17773      _fl_set_xyplot_fontsize(pObject, isize) 
17774   
17775   
17776 -def fl_set_xyplot_fontstyle(pObject, style): 
17777      """ 
17778          fl_set_xyplot_fontstyle(pObject, style) 
17779   
17780          @param pObject : pointer to object 
17781      """ 
17782   
17783      _fl_set_xyplot_fontstyle = cfuncproto( 
17784              load_so_libforms(), "fl_set_xyplot_fontstyle", 
17785              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17786              """void fl_set_xyplot_fontstyle(FL_OBJECT * ob, int style) DEPRECATED 
17787              """) 
17788      warn_deprecated_function("Use fl_set_lstyle, instead.") 
17789      istyle = convert_to_int(style) 
17790      keep_elem_refs(pObject, style, istyle) 
17791      _fl_set_xyplot_fontstyle(pObject, istyle) 
17792   
17793   
17794 -def fl_xyplot_s2w(pObject, sx, sy, wx, wy): 
17795      """ 
17796          fl_xyplot_s2w(pObject, sx, sy, wx, wy) 
17797   
17798          @param pObject : pointer to object 
17799      """ 
17800   
17801      _fl_xyplot_s2w = cfuncproto( 
17802              load_so_libforms(), "fl_xyplot_s2w", 
17803              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double, 
17804              cty.POINTER(cty.c_float), cty.POINTER(cty.c_float)], 
17805              """void fl_xyplot_s2w(FL_OBJECT * ob, double sx, double sy, 
17806                 float * wx, float * wy) 
17807              """) 
17808      fsx = convert_to_double(sx) 
17809      fsy = convert_to_double(sy) 
17810      keep_elem_refs(pObject, sx, sy, wx, wy, fsx, fsy) 
17811      _fl_xyplot_s2w(pObject, fsx, fsy, wx, wy) 
17812   
17813   
17814 -def fl_xyplot_w2s(pObject, wx, wy, sx, sy): 
17815      """ 
17816          fl_xyplot_w2s(pObject, wx, wy, sx, sy) 
17817   
17818          @param pObject : pointer to object 
17819      """ 
17820   
17821      _fl_xyplot_w2s = cfuncproto( 
17822              load_so_libforms(), "fl_xyplot_w2s", 
17823              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double, 
17824              cty.POINTER(cty.c_float), cty.POINTER(cty.c_float)], 
17825              """void fl_xyplot_w2s(FL_OBJECT * ob, double wx, double wy, 
17826                 float * sx, float * sy) 
17827              """) 
17828      fwx = convert_to_double(wx) 
17829      fwy = convert_to_double(wy) 
17830      keep_elem_refs(pObject, wx, wy, sx, sy, fwx, fwy) 
17831      _fl_xyplot_w2s(pObject, fwx, fwy, sx, sy) 
17832   
17833   
17834 -def fl_set_xyplot_xscale(pObject, scale, base): 
17835      """ 
17836          fl_set_xyplot_xscale(pObject, scale, base) 
17837   
17838          @param pObject : pointer to object 
17839      """ 
17840   
17841      _fl_set_xyplot_xscale = cfuncproto( 
17842              load_so_libforms(), "fl_set_xyplot_xscale", 
17843              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double], 
17844              """void fl_set_xyplot_xscale(FL_OBJECT * ob, int scale, 
17845                 double base) 
17846              """) 
17847      iscale = convert_to_int(scale) 
17848      fbase = convert_to_double(base) 
17849      keep_elem_refs(pObject, scale, base, iscale, fbase) 
17850      _fl_set_xyplot_xscale(pObject, iscale, fbase) 
17851   
17852   
17853 -def fl_set_xyplot_yscale(pObject, scale, base): 
17854      """ 
17855          fl_set_xyplot_yscale(pObject, scale, base) 
17856   
17857          @param pObject : pointer to object 
17858      """ 
17859   
17860      _fl_set_xyplot_yscale = cfuncproto( 
17861              load_so_libforms(), "fl_set_xyplot_yscale", 
17862              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double], 
17863              """void fl_set_xyplot_yscale(FL_OBJECT * ob, int scale, 
17864                 double base) 
17865              """) 
17866      iscale = convert_to_int(scale) 
17867      fbase = convert_to_double(base) 
17868      keep_elem_refs(pObject, scale, base, iscale, fbase) 
17869      _fl_set_xyplot_yscale(pObject, iscale, fbase) 
17870   
17871   
17872 -def fl_clear_xyplot(pObject): 
17873      """ 
17874          fl_clear_xyplot(pObject) 
17875   
17876          @param pObject : pointer to object 
17877      """ 
17878   
17879      _fl_clear_xyplot = cfuncproto( 
17880              load_so_libforms(), "fl_clear_xyplot", 
17881              None, [cty.POINTER(FL_OBJECT)], 
17882              """void fl_clear_xyplot(FL_OBJECT * ob) 
17883              """) 
17884      keep_elem_refs(pObject) 
17885      _fl_clear_xyplot(pObject) 
17886   
17887   
17888 -def fl_set_xyplot_linewidth(pObject, idnum, lw): 
17889      """ 
17890          fl_set_xyplot_linewidth(pObject, idnum, lw) 
17891   
17892          @param pObject : pointer to object 
17893      """ 
17894   
17895      _fl_set_xyplot_linewidth = cfuncproto( 
17896              load_so_libforms(), "fl_set_xyplot_linewidth", 
17897              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
17898              """void fl_set_xyplot_linewidth(FL_OBJECT * ob, int id, int lw) 
17899              """) 
17900      iidnum = convert_to_int(idnum) 
17901      ilw = convert_to_int(lw) 
17902      keep_elem_refs(pObject, idnum, lw, iidnum, ilw) 
17903      _fl_set_xyplot_linewidth(pObject, iidnum, ilw) 
17904   
17905   
17906 -def fl_set_xyplot_xgrid(pObject, xgrid): 
17907      """ 
17908          fl_set_xyplot_xgrid(pObject, xgrid) 
17909   
17910          @param pObject : pointer to object 
17911      """ 
17912   
17913      _fl_set_xyplot_xgrid = cfuncproto( 
17914              load_so_libforms(), "fl_set_xyplot_xgrid", 
17915              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17916              """void fl_set_xyplot_xgrid(FL_OBJECT * ob, int xgrid) 
17917              """) 
17918      ixgrid = convert_to_int(xgrid) 
17919      keep_elem_refs(pObject, xgrid, ixgrid) 
17920      _fl_set_xyplot_xgrid(pObject, ixgrid) 
17921   
17922   
17923 -def fl_set_xyplot_ygrid(pObject, ygrid): 
17924      """ 
17925          fl_set_xyplot_ygrid(pObject, ygrid) 
17926   
17927          @param pObject : pointer to object 
17928      """ 
17929   
17930      _fl_set_xyplot_ygrid = cfuncproto( 
17931              load_so_libforms(), "fl_set_xyplot_ygrid", 
17932              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17933              """void fl_set_xyplot_ygrid(FL_OBJECT * ob, int ygrid) 
17934              """) 
17935      iygrid = convert_to_int(ygrid) 
17936      keep_elem_refs(pObject, ygrid, iygrid) 
17937      _fl_set_xyplot_ygrid(pObject, iygrid) 
17938   
17939   
17940 -def fl_set_xyplot_grid_linestyle(pObject, style): 
17941      """ 
17942          fl_set_xyplot_grid_linestyle(pObject, style) -> num. 
17943   
17944          @param pObject : pointer to object 
17945      """ 
17946   
17947      _fl_set_xyplot_grid_linestyle = cfuncproto( 
17948              load_so_libforms(), "fl_set_xyplot_grid_linestyle", 
17949              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
17950              """int fl_set_xyplot_grid_linestyle(FL_OBJECT * ob, int style) 
17951              """) 
17952      istyle = convert_to_int(style) 
17953      keep_elem_refs(pObject, style, istyle) 
17954      retval = _fl_set_xyplot_grid_linestyle(pObject, istyle) 
17955      return retval 
17956   
17957   
17958 -def fl_set_xyplot_alphaxtics(pObject, m, s): 
17959      """ 
17960          fl_set_xyplot_alphaxtics(pObject, m, s) 
17961   
17962          @param pObject : pointer to object 
17963      """ 
17964   
17965      _fl_set_xyplot_alphaxtics = cfuncproto( 
17966              load_so_libforms(), "fl_set_xyplot_alphaxtics", 
17967              None, [cty.POINTER(FL_OBJECT), STRING, STRING], 
17968              """void fl_set_xyplot_alphaxtics(FL_OBJECT * ob, const char * m, 
17969                 const char * s) 
17970              """) 
17971      sm = convert_to_string(m) 
17972      ss = convert_to_string(s) 
17973      keep_elem_refs(pObject, m, s, sm, ss) 
17974      _fl_set_xyplot_alphaxtics(pObject, sm, ss) 
17975   
17976   
17977 -def fl_set_xyplot_alphaytics(pObject, m, s): 
17978      """ 
17979          fl_set_xyplot_alphaytics(pObject, m, s) 
17980   
17981          @param pObject : pointer to object 
17982      """ 
17983   
17984      _fl_set_xyplot_alphaytics = cfuncproto( 
17985              load_so_libforms(), "fl_set_xyplot_alphaytics", 
17986              None, [cty.POINTER(FL_OBJECT), STRING, STRING], 
17987              """void fl_set_xyplot_alphaytics(FL_OBJECT * ob, const char * m, 
17988                 const char * s) 
17989              """) 
17990      sm = convert_to_string(m) 
17991      ss = convert_to_string(s) 
17992      keep_elem_refs(pObject, m, s, sm, ss) 
17993      _fl_set_xyplot_alphaytics(pObject, sm, ss) 
17994   
17995   
17996 -def fl_set_xyplot_fixed_xaxis(pObject, lm, rm): 
17997      """ 
17998          fl_set_xyplot_fixed_xaxis(pObject, lm, rm) 
17999   
18000          @param pObject : pointer to object 
18001      """ 
18002   
18003      _fl_set_xyplot_fixed_xaxis = cfuncproto( 
18004              load_so_libforms(), "fl_set_xyplot_fixed_xaxis", 
18005              None, [cty.POINTER(FL_OBJECT), STRING, STRING], 
18006              """void fl_set_xyplot_fixed_xaxis(FL_OBJECT * ob, const char * lm, 
18007                 const char * rm) 
18008              """) 
18009      slm = convert_to_string(lm) 
18010      srm = convert_to_string(rm) 
18011      keep_elem_refs(pObject, lm, rm, slm, srm) 
18012      _fl_set_xyplot_fixed_xaxis(pObject, slm, srm) 
18013   
18014   
18015 -def fl_set_xyplot_fixed_yaxis(pObject, bm, tm): 
18016      """ 
18017          fl_set_xyplot_fixed_yaxis(pObject, bm, tm) 
18018   
18019          @param pObject : pointer to object 
18020      """ 
18021   
18022      _fl_set_xyplot_fixed_yaxis = cfuncproto( 
18023              load_so_libforms(), "fl_set_xyplot_fixed_yaxis", 
18024              None, [cty.POINTER(FL_OBJECT), STRING, STRING], 
18025              """void fl_set_xyplot_fixed_yaxis(FL_OBJECT * ob, const char * bm, 
18026                 const char * tm) 
18027              """) 
18028      sbm = convert_to_string(bm) 
18029      stm = convert_to_string(tm) 
18030      keep_elem_refs(pObject, bm, tm, sbm, stm) 
18031      _fl_set_xyplot_fixed_yaxis(pObject, sbm, stm) 
18032   
18033   
18034 -def fl_interpolate(wx, wy, nin, x, y, grid, ndeg): 
18035      """ fl_interpolate(wx, wy, nin, x, y, grid, ndeg) -> num. 
18036      """ 
18037   
18038      _fl_interpolate = cfuncproto( 
18039              load_so_libforms(), "fl_interpolate", 
18040              cty.c_int, [cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 
18041              cty.c_int, cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 
18042              cty.c_double, cty.c_int], 
18043              """int fl_interpolate(const char * wx, const char * wy, int nin, 
18044                 float * x, float * y, double grid, int ndeg) 
18045              """) 
18046      inin = convert_to_int(nin) 
18047      fgrid = convert_to_double(grid) 
18048      indeg = convert_to_int(ndeg) 
18049      keep_elem_refs(wx, wy, nin, x, y, grid, ndeg, inin, fgrid, indeg) 
18050      retval = _fl_interpolate(wx, wy, inin, x, y, fgrid, indeg) 
18051      return retval 
18052   
18053   
18054 -def fl_spline_interpolate(wx, wy, nin, x, y, grid): 
18055      """ fl_spline_interpolate(wx, wy, nin, x, y, grid) -> num. 
18056      """ 
18057   
18058      _fl_spline_interpolate = cfuncproto( 
18059              load_so_libforms(), "fl_spline_interpolate", 
18060              cty.c_int, [cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 
18061              cty.c_int, cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 
18062              cty.c_double], 
18063              """int fl_spline_interpolate(const char * wx, const char * wy, 
18064                 int nin, float * x, float * y, double grid) 
18065              """) 
18066      inin = convert_to_int(nin) 
18067      fgrid = convert_to_double(grid) 
18068      keep_elem_refs(wx, wy, nin, x, y, grid, inin, fgrid) 
18069      retval = _fl_spline_interpolate(wx, wy, inin, x, y, fgrid) 
18070      return retval 
18071   
18072   
18073  FL_XYPLOT_SYMBOL = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), cty.c_int, 
18074              cty.POINTER(FL_POINT), cty.c_int, cty.c_int, cty.c_int) 
18075   
18076 -def fl_set_xyplot_symbol(pObject, idnum, py_XyPlotSymbol): 
18077      """ 
18078          fl_set_xyplot_symbol(pObject, idnum, py_XyPlotSymbol) -> xyplot_symbol func. 
18079   
18080          @param pObject : pointer to object 
18081      """ 
18082   
18083      _fl_set_xyplot_symbol = cfuncproto( 
18084              load_so_libforms(), "fl_set_xyplot_symbol", 
18085              FL_XYPLOT_SYMBOL, [cty.POINTER(FL_OBJECT), cty.c_int, 
18086              FL_XYPLOT_SYMBOL], 
18087              """FL_XYPLOT_SYMBOL fl_set_xyplot_symbol(FL_OBJECT * ob, int id, 
18088                 FL_XYPLOT_SYMBOL symbol) 
18089              """) 
18090      iidnum = convert_to_int(idnum) 
18091      c_XyPlotSymbol = FL_XYPLOT_SYMBOL(py_XyPlotSymbol) 
18092      keep_cfunc_refs(c_XyPlotSymbol, py_XyPlotSymbol) 
18093      keep_elem_refs(pObject, idnum, iidnum) 
18094      retval = _fl_set_xyplot_symbol(pObject, iidnum, c_XyPlotSymbol) 
18095      return retval 
18096   
18097   
18098 -def fl_set_xyplot_mark_active(pObject, y): 
18099      """ 
18100          fl_set_xyplot_mark_active(pObject, y) -> num. 
18101   
18102          @param pObject : pointer to object 
18103      """ 
18104   
18105      _fl_set_xyplot_mark_active = cfuncproto( 
18106              load_so_libforms(), "fl_set_xyplot_mark_active", 
18107              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
18108              """int fl_set_xyplot_mark_active(FL_OBJECT * ob, int y) 
18109              """) 
18110      iy = convert_to_int(y) 
18111      keep_elem_refs(pObject, y, iy) 
18112      retval = _fl_set_xyplot_mark_active(pObject, iy) 
18113      return retval 
18114   
18115   
18116  # the following (fl_fheight) etc. were never documented and were 
18117  # removed from V0.89, but apparently this broke some applications that 
18118  # were using them. Put them back in 10/22/00 
18119   
18120 -def fl_gc_(): 
18121      """ fl_gc_() -> gc 
18122      """ 
18123   
18124      _fl_gc_ = cfuncproto( 
18125              load_so_libforms(), "fl_gc_", 
18126              GC, [], 
18127              """GC fl_gc_() 
18128              """) 
18129      retval = _fl_gc_() 
18130      return retval 
18131   
18132   
18133 -def fl_textgc_(): 
18134      """ fl_textgc_() -> gc 
18135      """ 
18136   
18137      _fl_textgc_ = cfuncproto( 
18138              load_so_libforms(), "fl_textgc_", 
18139              GC, [], 
18140              """)GC fl_textgc_() 
18141              """) 
18142      retval = _fl_textgc_() 
18143      return retval 
18144   
18145   
18146 -def fl_fheight_(): 
18147      """ fl_fheight_() -> num. 
18148      """ 
18149   
18150      _fl_fheight_ = cfuncproto( 
18151              load_so_libforms(), "fl_fheight_", 
18152              cty.c_int, [], 
18153              """int fl_fheight_() 
18154              """) 
18155      retval = _fl_fheight_() 
18156      return retval 
18157   
18158   
18159 -def fl_fdesc_(): 
18160      """ fl_fdesc_() -> num. 
18161      """ 
18162   
18163      _fl_fdesc_ = cfuncproto( 
18164              load_so_libforms(), "fl_fdesc_", 
18165              cty.c_int, [], 
18166              """int fl_fdesc_() 
18167              """) 
18168      retval = _fl_fdesc_() 
18169      return retval 
18170   
18171   
18172 -def fl_cur_win_(): 
18173      """ fl_cur_win_() -> window 
18174      """ 
18175   
18176      _fl_cur_win_ = cfuncproto( 
18177              load_so_libforms(), "fl_cur_win_", 
18178              Window, [], 
18179              """Window fl_cur_win_() 
18180              """) 
18181      retval = _fl_cur_win_() 
18182      return retval 
18183   
18184   
18185 -def fl_cur_fs_(): 
18186      """ fl_cur_fs_() -> XFontStruct class 
18187      """ 
18188   
18189      _fl_cur_fs_ = cfuncproto( 
18190              load_so_libforms(), "fl_cur_fs_", 
18191              cty.POINTER(XFontStruct), [], 
18192              """XFontStruct * fl_cur_fs_() 
18193              """) 
18194      retval = _fl_cur_fs_() 
18195      return retval 
18196   
18197   
18198  # commented to prevent a SegmentationFault during installation --LK 
18199  #fl_textgc = fl_textgc_() 
18200  fl_textgc = fl_textgc_ 
18201  #fl_gc = fl_gc_() 
18202  fl_gc = fl_gc_ 
18203  #fl_cur_win = fl_cur_win_() 
18204  fl_cur_win = fl_cur_win_ 
18205  #fl_fheight = fl_fheight_() 
18206  fl_fheight = fl_fheight_ 
18207  #fl_fdesc = fl_fdesc_() 
18208  fl_fdesc = fl_fdesc_ 
18209  #fl_cur_fs = fl_cur_fs_() 
18210  fl_cur_fs = fl_cur_fs_ 
18211   
18212   
18213 -def fl_display_(): 
18214      """ fl_display_() -> pDisplay 
18215      """ 
18216   
18217      _fl_display_ = cfuncproto( 
18218              load_so_libforms(), "fl_display_", 
18219              cty.POINTER(Display), [], 
18220              """Display * fl_display_() 
18221              """) 
18222      retval = _fl_display_() 
18223      return retval 
18224   
18225   
18226   
18227  ######################### 
18228  # flimage.h 
18229  # Image related routines 
18230  ######################### 
18231   
18232  # low-level, maybe unused in python --LK 
18233  #def fl_safe_free(p): 
18234  #    if p: 
18235  #        fl_free(p) 
18236  #        p = None        # UNSURE 
18237   
18238 -def FL_RGB2GRAY(r, g, b): 
18239      return cty.c_uint((78 * (r) + 150 * (g) + 28 * (b)) >> 8) 
18240   
18241   
18242  # if PCBITS is not 8, we need to apply the RGBmask 
18243   
18244 -def FL_IsRGB(im): 
18245      return (im.type == FL_IMAGE_RGB) 
18246   
18247 -def FL_IsPacked(im): 
18248      return (im.type == FL_IMAGE_PACKED) 
18249   
18250   
18251 -def flimage_setup(pImageSetup): 
18252      """ flimage_setup(setup) 
18253      """ 
18254   
18255      _flimage_setup = cfuncproto( 
18256              load_so_libflimage(), "flimage_setup", 
18257              None, [cty.POINTER(FLIMAGE_SETUP)], 
18258              """void flimage_setup(FLIMAGE_SETUP * setup) 
18259              """) 
18260      keep_elem_refs(pImageSetup) 
18261      _flimage_setup(pImageSetup) 
18262   
18263   
18264  # basic IO routines 
18265   
18266 -def flimage_load(filename): 
18267      """ flimage_load(filename) -> pImage 
18268      """ 
18269   
18270      _flimage_load = cfuncproto( 
18271              load_so_libflimage(), "flimage_load", 
18272              cty.POINTER(FL_IMAGE), [STRING], 
18273              """FL_IMAGE * flimage_load(const char * file) 
18274              """) 
18275      sfilename = convert_to_string(filename) 
18276      keep_elem_refs(filename, sfilename) 
18277      retval = _flimage_load(sfilename) 
18278      return retval 
18279   
18280   
18281 -def flimage_read(pImage): 
18282      """ flimage_read(pImage) -> pImage 
18283      """ 
18284   
18285      _flimage_read = cfuncproto( 
18286              load_so_libflimage(), "flimage_read", 
18287              cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE)], 
18288              """FL_IMAGE * flimage_read(FL_IMAGE * im) 
18289              """) 
18290      keep_elem_refs(pImage) 
18291      retval = _flimage_read(pImage) 
18292      return retval 
18293   
18294   
18295 -def flimage_dump(pImage, p2, p3): 
18296      """ flimage_dump(pImage, p2, p3) -> num. 
18297      """ 
18298   
18299      _flimage_dump = cfuncproto( 
18300              load_so_libflimage(), "flimage_dump", 
18301              cty.c_int, [cty.POINTER(FL_IMAGE), STRING, STRING], 
18302              """int flimage_dump(FL_IMAGE * p1, const char * p2, 
18303                 const char * p3) 
18304              """) 
18305      sp2 = convert_to_string(p2) 
18306      sp3 = convert_to_string(p3) 
18307      keep_elem_refs(pImage, p2, p3, sp2, sp3) 
18308      retval = _flimage_dump(pImage, sp2, sp3) 
18309      return retval 
18310   
18311   
18312 -def flimage_close(pImage): 
18313      """ flimage_close(pImage) -> num. 
18314      """ 
18315   
18316      _flimage_close = cfuncproto( 
18317              load_so_libflimage(), "flimage_close", 
18318              cty.c_int, [cty.POINTER(FL_IMAGE)], 
18319              """int flimage_close(FL_IMAGE * p1) 
18320              """) 
18321      keep_elem_refs(pImage) 
18322      retval = _flimage_close(pImage) 
18323      return retval 
18324   
18325   
18326 -def flimage_alloc(): 
18327      """ flimage_alloc() -> pImage 
18328      """ 
18329   
18330      _flimage_alloc = cfuncproto( 
18331              load_so_libflimage(), "flimage_alloc", 
18332              cty.POINTER(FL_IMAGE), [], 
18333              """FL_IMAGE * flimage_alloc() 
18334              """) 
18335      retval = _flimage_alloc() 
18336      return retval 
18337   
18338   
18339 -def flimage_getmem(pImage): 
18340      """ flimage_getmem(pImage) -> num. 
18341      """ 
18342   
18343      _flimage_getmem = cfuncproto( 
18344              load_so_libflimage(), "flimage_getmem", 
18345              cty.c_int, [cty.POINTER(FL_IMAGE)], 
18346              """int flimage_getmem(FL_IMAGE * p1) 
18347              """) 
18348      keep_elem_refs(pImage) 
18349      retval = _flimage_getmem(pImage) 
18350      return retval 
18351   
18352   
18353 -def flimage_is_supported(p1): 
18354      """ flimage_is_supported(p1) -> num. 
18355      """ 
18356   
18357      _flimage_is_supported = cfuncproto( 
18358              load_so_libflimage(), "flimage_is_supported", 
18359              cty.c_int, [STRING], 
18360              """int flimage_is_supported(const char * p1) 
18361              """) 
18362      sp1 = convert_to_string(p1) 
18363      keep_elem_refs(p1, sp1) 
18364      retval = _flimage_is_supported(sp1) 
18365      return retval 
18366   
18367   
18368 -def flimage_description_via_filter(pImage, p2, p3, p4): 
18369      """ flimage_description_via_filter(pImage, p2, p3, p4) -> num. 
18370      """ 
18371   
18372      _flimage_description_via_filter = cfuncproto( 
18373              load_so_libflimage(), "flimage_description_via_filter", 
18374              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(STRING), STRING, 
18375              cty.c_int], 
18376              """int flimage_description_via_filter(FL_IMAGE * p1, 
18377                 const char * p2, const char * p3, int p4) 
18378              """) 
18379      sp3 = convert_to_string(p3) 
18380      ip4 = convert_to_string(p4) 
18381      keep_elem_refs(pImage, p2, p3, p4, sp3, ip4) 
18382      retval = _flimage_description_via_filter(pImage, p2, sp3, ip4) 
18383      return retval 
18384   
18385   
18386 -def flimage_write_via_filter(pImage, p2, p3, p4): 
18387      """ flimage_write_via_filter(pImage, p2, p3, p4) -> num. 
18388      """ 
18389   
18390      _flimage_write_via_filter = cfuncproto( 
18391              load_so_libflimage(), "flimage_write_via_filter", 
18392              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(STRING), 
18393              cty.POINTER(STRING), cty.c_int], 
18394              """int flimage_write_via_filter(FL_IMAGE * p1, const char * p2, 
18395                 const char * p3, int p4) 
18396              """) 
18397      ip4 = convert_to_int(p4) 
18398      keep_elem_refs(pImage, p2, p3, p4, ip4) 
18399      retval = _flimage_write_via_filter(pImage, p2, p3, ip4) 
18400      return retval 
18401   
18402   
18403 -def flimage_free(pImage): 
18404      """ flimage_free(pImage) -> num. 
18405      """ 
18406   
18407      _flimage_free = cfuncproto( 
18408              load_so_libflimage(), "flimage_free", 
18409              cty.c_int, [cty.POINTER(FL_IMAGE)], 
18410              """int flimage_free(FL_IMAGE * p1) 
18411              """) 
18412      keep_elem_refs(pImage) 
18413      retval = _flimage_free(pImage) 
18414      return retval 
18415   
18416   
18417 -def flimage_display(pImage, win): 
18418      """ flimage_display(pImage, win) -> num. 
18419      """ 
18420   
18421      _flimage_display = cfuncproto( 
18422              load_so_libflimage(), "flimage_display", 
18423              cty.c_int, [cty.POINTER(FL_IMAGE), Window], 
18424              """int flimage_display(FL_IMAGE * p1, Window p2) 
18425              """) 
18426      ulwin = convert_to_Window(win) 
18427      keep_elem_refs(pImage, win, ulwin) 
18428      retval = _flimage_display(pImage, ulwin) 
18429      return retval 
18430   
18431   
18432 -def flimage_sdisplay(pImage, win): 
18433      """ flimage_sdisplay(pImage, win) -> num. 
18434      """ 
18435   
18436      _flimage_sdisplay = cfuncproto( 
18437              load_so_libflimage(), "flimage_sdisplay", 
18438              cty.c_int, [cty.POINTER(FL_IMAGE), Window], 
18439              """int flimage_sdisplay(FL_IMAGE * p1, Window p2) 
18440              """) 
18441      ulwin = convert_to_Window(win) 
18442      keep_elem_refs(pImage, win, ulwin) 
18443      retval = _flimage_sdisplay(pImage, ulwin) 
18444      return retval 
18445   
18446   
18447 -def flimage_convert(pImage, p2, p3): 
18448      """ flimage_convert(pImage, p2, p3) -> num. 
18449      """ 
18450   
18451      _flimage_convert = cfuncproto( 
18452              load_so_libflimage(), "flimage_convert", 
18453              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int], 
18454              """int flimage_convert(FL_IMAGE * p1, int p2, int p3) 
18455              """) 
18456      ip2 = convert_to_int(p2) 
18457      ip3 = convert_to_int(p3) 
18458      keep_elem_refs(pImage, p2, p3, ip2, ip3) 
18459      retval = _flimage_convert(pImage, ip2, ip3) 
18460      return retval 
18461   
18462   
18463 -def flimage_type_name(flimagetype): 
18464      """ flimage_type_name(flimagetype) -> name string 
18465      """ 
18466   
18467      _flimage_type_name = cfuncproto( 
18468              load_so_libflimage(), "flimage_type_name", 
18469              STRING, [cty.c_int], 
18470              """const char * flimage_type_name(int type) 
18471              """) 
18472      iflimagetype = convert_to_int(flimagetype) 
18473      keep_elem_refs(flimagetype, iflimagetype) 
18474      retval = _flimage_type_name(iflimagetype) 
18475      return retval 
18476   
18477   
18478 -def flimage_add_text(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11): 
18479      """ flimage_add_text(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11) -> num. 
18480      """ 
18481   
18482      _flimage_add_text = cfuncproto( 
18483              load_so_libflimage(), "flimage_add_text", 
18484              cty.c_int, [cty.POINTER(FL_IMAGE), STRING, cty.c_int, cty.c_int, 
18485              cty.c_int, cty.c_uint, cty.c_uint, cty.c_int, cty.c_double, 
18486              cty.c_double, cty.c_int], 
18487              """int flimage_add_text(FL_IMAGE * p1, const char * p2, int p3, 
18488                 int p4, int p5, unsigned int p6, unsigned int p7, int p8, 
18489                 double p9, double p10, int p11) 
18490              """) 
18491      stext = convert_to_string(text) 
18492      ip3 = convert_to_int(p3) 
18493      ip4 = convert_to_int(p4) 
18494      ip5 = convert_to_int(p5) 
18495      uip6 = convert_to_uint(p6) 
18496      uip7 = convert_to_uint(p7) 
18497      ip8 = convert_to_int(p8) 
18498      fp9 = convert_to_double(p9) 
18499      fp10 = convert_to_double(p10) 
18500      ip11 = convert_to_int(p11) 
18501      keep_elem_refs(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11, 
18502                     stext, ip3, ip4, ip5, uip6, uip7, ip8, fp9, fp10, ip11) 
18503      retval = _flimage_add_text(pImage, stext, ip3, ip4, ip5, uip6, uip7, 
18504                                 ip8, fp9, fp10, ip11) 
18505      return retval 
18506   
18507   
18508 -def flimage_add_text_struct(pImage, pImageText): 
18509      """ flimage_add_text_struct(pImage, pImageText) -> num. 
18510      """ 
18511   
18512      _flimage_add_text_struct = cfuncproto( 
18513              load_so_libflimage(), "flimage_add_text_struct", 
18514              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(FLIMAGE_TEXT)], 
18515              """int flimage_add_text_struct(FL_IMAGE * p1, const char * p2) 
18516              """) 
18517      keep_elem_refs(pImage, pImageText) 
18518      retval = _flimage_add_text_struct(pImage, pImageText) 
18519      return retval 
18520   
18521   
18522 -def flimage_delete_all_text(pImage): 
18523      """ flimage_delete_all_text(pImage) 
18524      """ 
18525   
18526      _flimage_delete_all_text = cfuncproto( 
18527              load_so_libflimage(), "flimage_delete_all_text", 
18528              None, [cty.POINTER(FL_IMAGE)], 
18529              """void flimage_delete_all_text(FL_IMAGE * p1) 
18530              """) 
18531      keep_elem_refs(pImage) 
18532      _flimage_delete_all_text(pImage) 
18533   
18534   
18535 -def flimage_add_marker(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11): 
18536      """ flimage_add_marker(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11) -> num. 
18537      """ 
18538   
18539      _flimage_add_marker = cfuncproto( 
18540              load_so_libflimage(), "flimage_add_marker", 
18541              cty.c_int, [cty.POINTER(FL_IMAGE), STRING, cty.c_double, 
18542              cty.c_double, cty.c_double, cty.c_double, cty.c_int, cty.c_int, 
18543              cty.c_int, cty.c_uint, cty.c_uint], 
18544              """int flimage_add_marker(FL_IMAGE * p1, const char * p2, 
18545                 double p3, double p4, double p5, double p6, int p7, 
18546                 int p8, int p9, unsigned int p10, unsigned int p11) 
18547              """) 
18548      stext = convert_to_string(text) 
18549      fp3 = convert_to_double(p3) 
18550      fp4 = convert_to_double(p4) 
18551      fp5 = convert_to_double(p5) 
18552      fp6 = convert_to_double(p6) 
18553      ip7 = convert_to_int(p7) 
18554      ip8 = convert_to_int(p8) 
18555      ip9 = convert_to_int(p9) 
18556      uip10 = convert_to_uint(p10) 
18557      uip11 = convert_to_uint(p11) 
18558      keep_elem_refs(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11, 
18559                     stext, fp3, fp4, fp5, fp6, ip7, ip8, ip9, uip10, uip11) 
18560      retval = _flimage_add_marker(pImage, stext, fp3, fp4, fp5, fp6, ip7, 
18561                                   ip8, ip9, uip10, uip11) 
18562      return retval 
18563   
18564   
18565 -def flimage_add_marker_struct(pImage, pImageMarker): 
18566      """ flimage_add_marker_struct(pImage, pImageMarker) -> num. 
18567      """ 
18568   
18569      _flimage_add_marker_struct = cfuncproto( 
18570              load_so_libflimage(), "flimage_add_marker_struct", 
18571              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(FLIMAGE_MARKER)], 
18572              """int flimage_add_marker_struct(FL_IMAGE * p1, const char * p2) 
18573              """) 
18574      keep_elem_refs(pImage, pImageMarker) 
18575      retval = _flimage_add_marker_struct(pImage, pImageMarker) 
18576      return retval 
18577   
18578   
18579 -def flimage_define_marker(text1, pImageMarker, text2): 
18580      """ flimage_define_marker(text1, pImageMarker, text2) -> num. 
18581      """ 
18582   
18583      _flimage_define_marker = cfuncproto( 
18584              load_so_libflimage(), "flimage_define_marker", 
18585              cty.c_int, [STRING, cty.POINTER(FLIMAGE_MARKER), STRING], 
18586              """int flimage_define_marker(const char *, void ( * ) 
18587                 (FLIMAGE_MARKER *), const char *) 
18588              """) 
18589      stext1 = convert_to_string(text1) 
18590      stext2 = convert_to_string(text2) 
18591      keep_elem_refs(text1, pImageMarker, text2, stext1, stext2) 
18592      retval = _flimage_define_marker(stext1, pImageMarker, stext2) 
18593      return retval 
18594   
18595   
18596 -def flimage_delete_all_markers(pImage): 
18597      """ flimage_delete_all_markers(pImage) 
18598      """ 
18599   
18600      _flimage_delete_all_markers = cfuncproto( 
18601              load_so_libflimage(), "flimage_delete_all_markers", 
18602              None, [cty.POINTER(FL_IMAGE)], 
18603              """void flimage_delete_all_markers(FL_IMAGE * p1) 
18604              """) 
18605      keep_elem_refs(pImage) 
18606      _flimage_delete_all_markers(pImage) 
18607   
18608   
18609 -def flimage_render_annotation(pImage, win): 
18610      """ flimage_render_annotation(pImage, win) -> num. 
18611      """ 
18612   
18613      _flimage_render_annotation = cfuncproto( 
18614              load_so_libflimage(), "flimage_render_annotation", 
18615              cty.c_int, [cty.POINTER(FL_IMAGE), FL_WINDOW], 
18616              """int flimage_render_annotation(FL_IMAGE * p1, FL_WINDOW p2) 
18617              """) 
18618      ulwin = convert_to_Window(win) 
18619      keep_elem_refs(pImage, win, ulwin) 
18620      retval = _flimage_render_annotation(pImage, ulwin) 
18621      return retval 
18622   
18623   
18624 -def flimage_error(pImage, text): 
18625      """ flimage_error(pImage, text) 
18626      """ 
18627   
18628      _flimage_error = cfuncproto( 
18629              load_so_libflimage(), "flimage_error", 
18630              None, [cty.POINTER(FL_IMAGE), STRING], 
18631              """void flimage_error(FL_IMAGE * p1, const char * p2) 
18632              """) 
18633      stext = convert_to_Window(text) 
18634      keep_elem_refs(pImage, text, stext) 
18635      _flimage_error(pImage, stext) 
18636   
18637   
18638  # built-in format supports 
18639   
18640 -def flimage_enable_pnm(): 
18641      """ flimage_enable_pnm() 
18642      """ 
18643   
18644      _flimage_enable_pnm = cfuncproto( 
18645              load_so_libflimage(), "flimage_enable_pnm", 
18646              None, [], 
18647              """void flimage_enable_pnm() 
18648              """) 
18649      _flimage_enable_pnm() 
18650   
18651   
18652 -def flimage_set_fits_bits(p1): 
18653      """ flimage_set_fits_bits(p1) -> num. 
18654      """ 
18655   
18656      _flimage_set_fits_bits = cfuncproto( 
18657              load_so_libflimage(), "flimage_set_fits_bits", 
18658              cty.c_int, [cty.c_int], 
18659              """int flimage_set_fits_bits(int p1) 
18660              """) 
18661      ip1 = convert_to_int(p1) 
18662      keep_elem_refs(p1, ip1) 
18663      retval = _flimage_set_fits_bits(ip1) 
18664      return retval 
18665   
18666   
18667 -def flimage_jpeg_output_options(pImageJpegOption): 
18668      """ flimage_jpeg_output_options(pImageJpegOption) 
18669      """ 
18670   
18671      _flimage_jpeg_output_options = cfuncproto( 
18672              load_so_libflimage(), "flimage_jpeg_output_options", 
18673              None, [cty.POINTER(FLIMAGE_JPEG_OPTION)], 
18674              """void flimage_jpeg_output_options(FLIMAGE_JPEG_OPTION * p1) 
18675              """) 
18676      keep_elem_refs(pImageJpegOption) 
18677      _flimage_jpeg_output_options(pImageJpegOption) 
18678   
18679   
18680 -def flimage_pnm_output_options(p1): 
18681      """ flimage_pnm_output_options(p1) 
18682      """ 
18683   
18684      _flimage_pnm_output_options = cfuncproto( 
18685              load_so_libflimage(), "flimage_pnm_output_options", 
18686              None, [cty.c_int], 
18687              """void flimage_pnm_output_options(int p1) 
18688              """) 
18689      ip1 = convert_to_int(p1) 
18690      keep_elem_refs(p1, ip1) 
18691      _flimage_pnm_output_options(ip1) 
18692   
18693   
18694 -def flimage_gif_output_options(p1): 
18695      """ flimage_gif_output_options(p1) 
18696      """ 
18697   
18698      _flimage_gif_output_options = cfuncproto( 
18699              load_so_libflimage(), "flimage_gif_output_options", 
18700              None, [cty.c_int], 
18701              """void flimage_gif_output_options(int p1) 
18702              """) 
18703      ip1 = convert_to_int(p1) 
18704      keep_elem_refs(p1, ip1) 
18705      _flimage_gif_output_options(ip1) 
18706   
18707   
18708 -def flimage_ps_options(): 
18709      """ flimage_ps_options() -> flps_control class 
18710      """ 
18711   
18712      _flimage_ps_options = cfuncproto( 
18713              load_so_libflimage(), "flimage_ps_options", 
18714              cty.POINTER(FLPS_CONTROL), [], 
18715              """FLPS_CONTROL * flimage_ps_options() 
18716              """) 
18717      retval = _flimage_ps_options() 
18718      return retval 
18719   
18720   
18721  flimage_jpeg_options = flimage_jpeg_output_options 
18722  flimage_pnm_options = flimage_pnm_output_options 
18723  flimage_gif_options = flimage_gif_output_options 
18724   
18725   
18726 -def flimage_get_number_of_formats(): 
18727      """ flimage_get_number_of_formats() -> num. 
18728      """ 
18729   
18730      _flimage_get_number_of_formats = cfuncproto( 
18731              load_so_libflimage(), "flimage_get_number_of_formats", 
18732              cty.c_int, [], 
18733              """int flimage_get_number_of_formats() 
18734              """) 
18735      retval = _flimage_get_number_of_formats() 
18736      return retval 
18737   
18738   
18739 -def flimage_get_format_info(p1): 
18740      """ flimage_get_format_info(p1) -> format_info class instance 
18741      """ 
18742   
18743      _flimage_get_format_info = cfuncproto( 
18744              load_so_libflimage(), "flimage_get_format_info", 
18745              cty.POINTER(FLIMAGE_FORMAT_INFO), [cty.c_int], 
18746              """const char * flimage_get_format_info(int p1) 
18747              """) 
18748      ip1 = convert_to_int(p1) 
18749      keep_elem_refs(p1, ip1) 
18750      retval = _flimage_get_format_info(ip1) 
18751      return retval 
18752   
18753   
18754 -def fl_get_matrix(nrows, ncols, esize): 
18755      """ fl_get_matrix(nrows, ncols, esize) -> ? 
18756      """ 
18757   
18758      _fl_get_matrix = cfuncproto( 
18759              load_so_libflimage(), "fl_get_matrix", 
18760              cty.c_void_p, [cty.c_int, cty.c_int, cty.c_uint], 
18761              """void * fl_get_matrix(int p1, int p2, unsigned int p3) 
18762              """) 
18763      inrows = convert_to_int(nrows) 
18764      incols = convert_to_int(ncols) 
18765      uiesize = convert_to_uint(esize) 
18766      keep_elem_refs(nrows, ncols, esize, inrows, incols, uiesize) 
18767      retval = _fl_get_matrix(inrows, incols, uiesize) 
18768      return retval 
18769   
18770   
18771 -def fl_make_matrix(nrows, ncols, esize, mem): 
18772      """ 
18773          fl_make_matrix(nrows, ncols, esize, mem) -> ? 
18774   
18775          Makes a matrix out of a given piece of memory. 
18776   
18777          @param nrows : number of rows 
18778          @param ncols : number of columns 
18779          @param esize : size of matrix 
18780          @param mem : memory 
18781      """ 
18782   
18783      _fl_make_matrix = cfuncproto( 
18784              load_so_libflimage(), "fl_make_matrix", 
18785              cty.c_void_p, [cty.c_int, cty.c_int, cty.c_uint, cty.c_void_p], 
18786              """void * fl_make_matrix(int p1, int p2, unsigned int p3, 
18787                 void * p4) 
18788              """) 
18789      inrows = convert_to_int(nrows) 
18790      incols = convert_to_int(ncols) 
18791      uiesize = convert_to_uint(esize) 
18792      pmem = cty.cast(mem, cty.c_void_p) 
18793      keep_elem_refs(nrows, ncols, esize, mem, inrows, incols, uiesize, pmem) 
18794      retval = _fl_make_matrix(inrows, incols, uiesize, pmem) 
18795      return retval 
18796   
18797   
18798 -def fl_free_matrix(mtrx): 
18799      """ fl_free_matrix(mtrx) 
18800      """ 
18801   
18802      _fl_free_matrix = cfuncproto( 
18803              load_so_libflimage(), "fl_free_matrix", 
18804              None, [cty.c_void_p], 
18805              """void fl_free_matrix(void * p1) 
18806              """) 
18807      pmtrx = cty.cast(mtrx, cty.c_void_p) 
18808      keep_elem_refs(mtrx, pmtrx) 
18809      _fl_free_matrix(pmtrx) 
18810   
18811   
18812  # This function is retained for compatibility reasons only. 
18813  # It returns 1 always. 
18814 -def fl_init_RGBdatabase(text): 
18815      """ fl_init_RGBdatabase(text) -> num. 
18816      """ 
18817   
18818      _fl_init_RGBdatabase = cfuncproto( 
18819              load_so_libflimage(), "fl_init_RGBdatabase", 
18820              cty.c_int, [STRING], 
18821              """int fl_init_RGBdatabase(const char * p1) 
18822              """) 
18823      stext = convert_to_string(text) 
18824      keep_elem_refs(text, stext) 
18825      retval = _fl_init_RGBdatabase(stext) 
18826      return retval 
18827   
18828   
18829 -def fl_lookup_RGBcolor(text, p2, p3, p4): 
18830      """ fl_lookup_RGBcolor(text, p2, p3, p4) -> num. 
18831      """ 
18832   
18833      _fl_lookup_RGBcolor = cfuncproto( 
18834              load_so_libflimage(), "fl_lookup_RGBcolor", 
18835              cty.c_int, [STRING, cty.POINTER(cty.c_int), \ 
18836              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 
18837              """int fl_lookup_RGBcolor(const char * p1, int * p2, 
18838                 int * p3, int * p4) 
18839              """) 
18840      stext = convert_to_string(text) 
18841      keep_elem_refs(text, p2, p3, p4) 
18842      retval = _fl_lookup_RGBcolor(stext, p2, p3, p4) 
18843      return retval 
18844   
18845   
18846  FLIMAGE_Identify = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FILE)) 
18847  FLIMAGE_Description = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_IMAGE)) 
18848  FLIMAGE_Read_Pixels = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_IMAGE)) 
18849  FLIMAGE_Write_Image = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_IMAGE)) 
18850   
18851 -def flimage_add_format(p1, p2, p3, p4, py_ImageIdentify, py_ImageDescription, 
18852                         py_ImageReadPixels, py_ImageWriteImage): 
18853      """ flimage_add_format(p1, p2, p3, p4, py_ImageIdentify, 
18854          py_ImageDescription, py_ImageReadPixels, py_ImageWriteImage) -> num. 
18855      """ 
18856   
18857      _flimage_add_format = cfuncproto( 
18858              load_so_libflimage(), "flimage_add_format", 
18859              cty.c_int, [STRING, STRING, STRING, cty.c_int, FLIMAGE_Identify, 
18860              FLIMAGE_Description, FLIMAGE_Read_Pixels, FLIMAGE_Write_Image], 
18861              """int flimage_add_format(const char * p1, const char * p2, 
18862                 const char * p3, int p4, FLIMAGE_Identify p5, 
18863                 FLIMAGE_Description p6, FLIMAGE_Read_Pixels p7, 
18864                 FLIMAGE_Write_Image p8) 
18865              """) 
18866      sp1 = convert_to_string(p1) 
18867      sp2 = convert_to_string(p2) 
18868      sp3 = convert_to_string(p3) 
18869      ip4 = convert_to_int(p4) 
18870      c_ImageIdentify = FLIMAGE_Identify(py_ImageIdentify) 
18871      c_ImageDescription = FLIMAGE_Description(py_ImageDescription) 
18872      c_ImageReadPixels = FLIMAGE_Read_Pixels(py_ImageReadPixels) 
18873      c_ImageWriteImage = FLIMAGE_Write_Image(py_ImageWriteImage) 
18874      keep_cfunc_refs(c_ImageIdentify, py_ImageIdentify, c_ImageDescription, \ 
18875                      py_ImageDescription, c_ImageReadPixels, py_ImageReadPixels, 
18876                      c_ImageWriteImage, py_ImageWriteImage) 
18877      keep_elem_refs(p1, p2, p3, p4, sp1, sp2, sp3, ip4) 
18878      retval = _flimage_add_format(sp1, sp2, sp3, ip4, c_ImageIdentify, \ 
18879                                   c_ImageDescription, c_ImageReadPixels, \ 
18880                                   c_ImageWriteImage) 
18881      return retval 
18882   
18883   
18884 -def flimage_set_annotation_support(p1, p2): 
18885      """ flimage_set_annotation_support(p1, p2) 
18886      """ 
18887   
18888      _flimage_set_annotation_support = cfuncproto( 
18889              load_so_libflimage(), "flimage_set_annotation_support", 
18890              None, [cty.c_int, cty.c_int], 
18891              """void flimage_set_annotation_support(int p1, int p2) 
18892              """) 
18893      ip1 = convert_to_int(p1) 
18894      ip2 = convert_to_int(p2) 
18895      keep_elem_refs(p1, p2, ip1, ip2) 
18896      _flimage_set_annotation_support(ip1, ip2) 
18897   
18898   
18899 -def flimage_getcolormap(pImage): 
18900      """ flimage_getcolormap(pImage) -> num. 
18901      """ 
18902   
18903      _flimage_getcolormap = cfuncproto( 
18904              load_so_libflimage(), "flimage_getcolormap", 
18905              cty.c_int, [cty.POINTER(FL_IMAGE)], 
18906              """int flimage_getcolormap(FL_IMAGE * p1) 
18907              """) 
18908      keep_elem_refs(pImage) 
18909      retval = _flimage_getcolormap(pImage) 
18910      return retval 
18911   
18912   
18913 -def fl_select_mediancut_quantizer(): 
18914      """ fl_select_mediancut_quantizer() 
18915      """ 
18916   
18917      _fl_select_mediancut_quantizer = cfuncproto( 
18918              load_so_libflimage(), "fl_select_mediancut_quantizer", 
18919              None, [], 
18920              """void fl_select_mediancut_quantizer() 
18921              """) 
18922      _fl_select_mediancut_quantizer() 
18923   
18924   
18925  # simple image processing routines 
18926   
18927 -def flimage_convolve(pImage, p2, p3, p4): 
18928      """ flimage_convolve(pImage, p2, p3, p4) -> num. 
18929      """ 
18930   
18931      _flimage_convolve = cfuncproto( 
18932              load_so_libflimage(), "flimage_convolve", 
18933              cty.c_int, [cty.POINTER(FL_IMAGE), 
18934              cty.POINTER(cty.POINTER(cty.c_int)), cty.c_int, cty.c_int], 
18935              """int flimage_convolve(FL_IMAGE * p1, int * * p2, int p3, 
18936                 int p4) 
18937              """) 
18938      ip3 = convert_to_int(p3) 
18939      ip4 = convert_to_int(p4) 
18940      keep_elem_refs(pImage, p2, p3, p4, ip3, ip4) 
18941      retval = _flimage_convolve(pImage, p2, ip3, ip4) 
18942      return retval 
18943   
18944   
18945 -def flimage_convolvea(pImage, p2, p3, p4): 
18946      """ flimage_convolvea(pImage, p2, p3, p4) -> num. 
18947      """ 
18948   
18949      _flimage_convolvea = cfuncproto( 
18950              load_so_libflimage(), "flimage_convolvea", 
18951              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(cty.c_int), 
18952              cty.c_int, cty.c_int], 
18953              """int flimage_convolvea(FL_IMAGE * p1, int * p2, int p3, int p4) 
18954              """) 
18955      keep_elem_refs(pImage, p2, p3, p4) 
18956      retval = _flimage_convolvea(pImage, p2, p3, p4) 
18957      return retval 
18958   
18959   
18960 -def flimage_tint(pImage, p2, p3): 
18961      """ flimage_tint(pImage, p2, p3) -> num. 
18962      """ 
18963   
18964      _flimage_tint = cfuncproto( 
18965              load_so_libflimage(), "flimage_tint", 
18966              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint, cty.c_double], 
18967              """int flimage_tint(FL_IMAGE * p1, unsigned int p2, double p3) 
18968              """) 
18969      keep_elem_refs(pImage, p2, p3) 
18970      retval = _flimage_tint(pImage, p2, p3) 
18971      return retval 
18972   
18973   
18974 -def flimage_rotate(pImage, p2, p3): 
18975      """ flimage_rotate(pImage, p2, p3) -> num. 
18976      """ 
18977   
18978      _flimage_rotate = cfuncproto( 
18979              load_so_libflimage(), "flimage_rotate", 
18980              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int], 
18981              """int flimage_rotate(FL_IMAGE * p1, int p2, int p3) 
18982              """) 
18983      ip2 = convert_to_int(p2) 
18984      ip3 = convert_to_int(p3) 
18985      keep_elem_refs(pImage, p2, p3, ip2, ip3) 
18986      retval = _flimage_rotate(pImage, ip2, ip3) 
18987      return retval 
18988   
18989   
18990 -def flimage_flip(pImage, p2): 
18991      """ flimage_flip(pImage, p2) -> num. 
18992      """ 
18993   
18994      _flimage_flip = cfuncproto( 
18995              load_so_libflimage(), "flimage_flip", 
18996              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int], 
18997              """int flimage_flip(FL_IMAGE * p1, int p2) 
18998              """) 
18999      ip2 = convert_to_int(p2) 
19000      keep_elem_refs(pImage, p2, ip2) 
19001      retval = _flimage_flip(pImage, ip2) 
19002      return retval 
19003   
19004   
19005 -def flimage_scale(pImage, p2, p3, p4): 
19006      """ flimage_scale(pImage, p2, p3, p4) -> num. 
19007      """ 
19008   
19009      _flimage_scale = cfuncproto( 
19010              load_so_libflimage(), "flimage_scale", 
19011              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, 
19012              cty.c_int], 
19013              """int flimage_scale(FL_IMAGE * p1, int p2, int p3, int p4) 
19014              """) 
19015      ip2 = convert_to_int(p2) 
19016      ip3 = convert_to_int(p3) 
19017      ip4 = convert_to_int(p4) 
19018      keep_elem_refs(pImage, p2, p3, p4, ip2, ip3, ip4) 
19019      retval = _flimage_scale(pImage, ip2, ip3, ip4) 
19020      return retval 
19021   
19022   
19023 -def flimage_warp(pImage, p2, p3, p4, p5): 
19024      """ flimage_warp(pImage, p2, p3, p4, p5) -> num. 
19025      """ 
19026   
19027      _flimage_warp = cfuncproto( 
19028              load_so_libflimage(), "flimage_warp", 
19029              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(cty.c_float * 2), 
19030              cty.c_int, cty.c_int, cty.c_int], 
19031              """int flimage_warp(FL_IMAGE * p1, float * p2, int p3, int p4, 
19032                 int p5) 
19033              """) 
19034      ip3 = convert_to_int(p3) 
19035      ip4 = convert_to_int(p4) 
19036      ip5 = convert_to_int(p5) 
19037      keep_elem_refs(pImage, p2, p3, p4, p5, ip3, ip4, ip5) 
19038      retval = _flimage_warp(pImage, p2, ip3, ip4, ip5) 
19039      return retval 
19040   
19041   
19042 -def flimage_autocrop(pImage, p2): 
19043      """ flimage_autocrop(pImage, p2) -> num. 
19044      """ 
19045   
19046      _flimage_autocrop = cfuncproto( 
19047              load_so_libflimage(), "flimage_autocrop", 
19048              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint], 
19049              """int flimage_autocrop(FL_IMAGE * p1, unsigned int p2) 
19050              """) 
19051      uip2 = convert_to_uint(p2) 
19052      keep_elem_refs(pImage, p2, uip2) 
19053      retval = _flimage_autocrop(pImage, uip2) 
19054      return retval 
19055   
19056   
19057  #def flimage_get_autocrop(pImage, bk, xl, yt, xr, yb)       *API change* 
19058 -def flimage_get_autocrop(pImage, bk): 
19059      """ flimage_get_autocrop(pImage, bk) -> num., xl, yt, xr, yb 
19060      """ 
19061   
19062      _flimage_get_autocrop = cfuncproto( 
19063              load_so_libflimage(), "flimage_get_autocrop", 
19064              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint, 
19065              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
19066              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 
19067              """int flimage_get_autocrop(FL_IMAGE * p1, unsigned int p2, 
19068                 int * p3, int * p4, int * p5, int * p6) 
19069              """) 
19070      uibk = convert_to_uint(bk) 
19071      xl, pxl = make_int_and_pointer() 
19072      yt, pyt = make_int_and_pointer() 
19073      xr, pxr = make_int_and_pointer() 
19074      yb, pyb = make_int_and_pointer() 
19075      keep_elem_refs(pImage, bk, uibk, xl, pxl, yt, pyt, xr, pxr, yb, pyb) 
19076      retval = _flimage_get_autocrop(pImage, uibk, pxl, pyt, pxr, pyb) 
19077      return retval, xl, yt, xr, yb 
19078   
19079   
19080 -def flimage_crop(pImage, p2, p3, p4, p5): 
19081      """ flimage_crop(pImage, p2, p3, p4, p5) -> num. 
19082      """ 
19083   
19084      _flimage_crop = cfuncproto( 
19085              load_so_libflimage(), "flimage_crop", 
19086              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, 
19087              cty.c_int, cty.c_int], 
19088              """int flimage_crop(FL_IMAGE * p1, int p2, int p3, 
19089                 int p4, int p5) 
19090              """) 
19091      ip2 = convert_to_int(p2) 
19092      ip3 = convert_to_int(p3) 
19093      ip4 = convert_to_int(p4) 
19094      ip5 = convert_to_int(p5) 
19095      keep_elem_refs(pImage, p2, p3, p4, p5, ip2, ip3, ip4, ip5) 
19096      retval = _flimage_crop(pImage, ip2, ip3, ip4, ip5) 
19097      return retval 
19098   
19099   
19100 -def flimage_replace_pixel(pImage, p2, p3): 
19101      """ flimage_replace_pixel(pImage, p2, p3) -> num. 
19102      """ 
19103   
19104      _flimage_replace_pixel = cfuncproto( 
19105              load_so_libflimage(), "flimage_replace_pixel", 
19106              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint, cty.c_uint], 
19107              """int flimage_replace_pixel(FL_IMAGE * p1, unsigned int p2, 
19108                 unsigned int p3) 
19109              """) 
19110      uip2 = convert_to_uint(p2) 
19111      uip3 = convert_to_uint(p3) 
19112      keep_elem_refs(pImage, p2, p3, uip2, uip3) 
19113      retval = _flimage_replace_pixel(pImage, uip2, uip3) 
19114      return retval 
19115   
19116   
19117 -def flimage_transform_pixels(pImage, red, green, blue): 
19118      """ flimage_transform_pixels(pImage, red, green, blue) -> num. 
19119      """ 
19120   
19121      _flimage_transform_pixels = cfuncproto( 
19122              load_so_libflimage(), "flimage_transform_pixels", 
19123              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(cty.c_int), 
19124              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 
19125              """int flimage_transform_pixels(FL_IMAGE * p1, int * p2, 
19126                 int * p3, int * p4) 
19127              """) 
19128      pred = cty.cast(red, cty.POINTER(cty.c_int)) 
19129      pgreen = cty.cast(green, cty.POINTER(cty.c_int)) 
19130      pblue = cty.cast(blue, cty.POINTER(cty.c_int)) 
19131      keep_elem_refs(pImage, red, green, blue, pred, pgreen, pblue) 
19132      retval = _flimage_transform_pixels(pImage, pred, pgreen, pblue) 
19133      return retval 
19134   
19135   
19136 -def flimage_windowlevel(pImage, p2, p3): 
19137      """ flimage_windowlevel(pImage, p2, p3) -> num. 
19138      """ 
19139   
19140      _flimage_windowlevel = cfuncproto( 
19141              load_so_libflimage(), "flimage_windowlevel", 
19142              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int], 
19143              """int flimage_windowlevel(FL_IMAGE * p1, int p2, int p3) 
19144              """) 
19145      ip2 = convert_to_int(p2) 
19146      ip3 = convert_to_int(p3) 
19147      keep_elem_refs(pImage, p2, p3, ip2, ip3) 
19148      retval = _flimage_windowlevel(pImage, ip2, ip3) 
19149      return retval 
19150   
19151   
19152 -def flimage_enhance(pImage, p2): 
19153      """ flimage_enhance(pImage, p2) -> num. 
19154      """ 
19155   
19156      _flimage_enhance = cfuncproto( 
19157              load_so_libflimage(), "flimage_enhance", 
19158              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int], 
19159              """int flimage_enhance(FL_IMAGE * p1, int p2) 
19160              """) 
19161      ip2 = convert_to_int(p2) 
19162      keep_elem_refs(pImage, p2, ip2) 
19163      retval = _flimage_enhance(pImage, ip2) 
19164      return retval 
19165   
19166   
19167 -def flimage_from_pixmap(pImage, pixmap): 
19168      """ flimage_from_pixmap(pImage, pixmap) -> num. 
19169      """ 
19170   
19171      _flimage_from_pixmap = cfuncproto( 
19172              load_so_libflimage(), "flimage_from_pixmap", 
19173              cty.c_int, [cty.POINTER(FL_IMAGE), Pixmap], 
19174              """int flimage_from_pixmap(FL_IMAGE * p1, Pixmap p2) 
19175              """) 
19176      ulpixmap = convert_to_Pixmap(pixmap) 
19177      keep_elem_refs(pImage, pixmap, ulpixmap) 
19178      retval = _flimage_from_pixmap(pImage, ulpixmap) 
19179      return retval 
19180   
19181   
19182 -def flimage_to_pixmap(pImage, win): 
19183      """ flimage_to_pixmap(pImage, win) -> pixmap 
19184      """ 
19185   
19186      _flimage_to_pixmap = cfuncproto( 
19187              load_so_libflimage(), "flimage_to_pixmap", 
19188              Pixmap, [cty.POINTER(FL_IMAGE), FL_WINDOW], 
19189              """Pixmap flimage_to_pixmap(FL_IMAGE * p1, FL_WINDOW p2) 
19190              """) 
19191      ulwin = convert_to_Window(win) 
19192      keep_elem_refs(pImage, win, ulwin) 
19193      retval = _flimage_to_pixmap(pImage, ulwin) 
19194      return retval 
19195   
19196   
19197 -def flimage_dup(pImage): 
19198      """ flimage_dup(pImage) -> pImage 
19199      """ 
19200   
19201      _flimage_dup = cfuncproto( 
19202              load_so_libflimage(), "flimage_dup", 
19203              cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE)], 
19204              """FL_IMAGE * flimage_dup(FL_IMAGE * p1) 
19205              """) 
19206      keep_elem_refs(pImage) 
19207      retval = _flimage_dup(pImage) 
19208      return retval 
19209   
19210   
19211  # Miscellaneous prototypes 
19212   
19213 -def fl_get_submatrix(inmtrx, rows, cols, r1, c1, rs, cs, esize): 
19214      """ fl_get_submatrix(inmtrx, rows, cols, r1, c1, rs, cs, esize) -> ? 
19215      """ 
19216   
19217      _fl_get_submatrix = cfuncproto( 
19218              load_so_libflimage(), "fl_get_submatrix", 
19219              cty.c_void_p, [cty.c_void_p, cty.c_int, cty.c_int, cty.c_int, 
19220              cty.c_int, cty.c_int, cty.c_int, cty.c_uint], 
19221              """void * fl_get_submatrix(void * p1, int p2, int p3, int p4, 
19222                 int p5, int p6, int p7, unsigned int p8) 
19223              """) 
19224      pinmtrx = cty.cast(inmtrx, cty.c_void_p) 
19225      irows = convert_to_int(rows) 
19226      icols = convert_to_int(cols) 
19227      ir1 = convert_to_int(r1) 
19228      ic1 = convert_to_int(c1) 
19229      irs = convert_to_int(rs) 
19230      ics = convert_to_int(cs) 
19231      uiesize = convert_to_uint(esize) 
19232      keep_elem_refs(inmtrx, rows, cols, r1, c1, rs, cs, esize, pinmtrx, \ 
19233                     irows, icols, ir1, ic1, irs, ics, uiesize) 
19234      retval = _fl_get_submatrix(pinmtrx, irows, icols, ir1, ic1, irs, ics, \ 
19235                                 uiesize) 
19236      return retval 
19237   
19238   
19239 -def fl_j2pass_quantize_packed(p1, p2, p3, p4, p5, p6, p7, p8, p9, pImage): 
19240      """ fl_j2pass_quantize_packed(p1, p2, p3, p4, p5, p6, p7, p8, p9, pImage) -> num. 
19241      """ 
19242   
19243      _fl_j2pass_quantize_packed = cfuncproto( 
19244              load_so_libflimage(), "fl_j2pass_quantize_packed", 
19245              cty.c_int, [cty.POINTER(cty.POINTER(cty.c_uint)), cty.c_int, 
19246              cty.c_int, cty.c_int, cty.POINTER(cty.POINTER(cty.c_ushort)), 
19247              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
19248              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
19249              cty.POINTER(FL_IMAGE)], 
19250              """int fl_j2pass_quantize_packed(unsigned int * * p1, int p2, 
19251                 int p3, int p4, short unsigned int * * p5, int * p6, 
19252                 int * p7, int * p8, int * p9, FL_IMAGE * p10) 
19253              """) 
19254      ip2 = convert_to_int(p2) 
19255      ip3 = convert_to_int(p3) 
19256      ip4 = convert_to_int(p4) 
19257      keep_elem_refs(p1, p2, p3, p4, p5, p6, p7, p8, p9, pImage, ip2, ip3, ip4) 
19258      retval = _fl_j2pass_quantize_packed(p1, ip2, ip3, ip4, p5, p6, p7, p8, \ 
19259                                          p9, pImage) 
19260      return retval 
19261   
19262   
19263 -def fl_j2pass_quantize_rgb(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, pImage): 
19264      """ fl_j2pass_quantize_rgb(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, pImage) -> num. 
19265      """ 
19266   
19267      _fl_j2pass_quantize_rgb = cfuncproto( 
19268              load_so_libflimage(), "fl_j2pass_quantize_rgb", 
19269              cty.c_int, [cty.POINTER(cty.POINTER(cty.c_ubyte)), 
19270              cty.POINTER(cty.POINTER(cty.c_ubyte)), 
19271              cty.POINTER(cty.POINTER(cty.c_ubyte)), cty.c_int, cty.c_int, 
19272              cty.c_int, cty.POINTER(cty.POINTER(cty.c_ushort)), 
19273              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
19274              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
19275              cty.POINTER(FL_IMAGE)], 
19276              """int fl_j2pass_quantize_rgb(unsigned char * * p1, 
19277                 unsigned char * * p2, unsigned char * * p3, int p4, int p5, 
19278                 int p6, short unsigned int * * p7, int * p8, int * p9, 
19279                 int * p10, int * p11, FL_IMAGE * p12) 
19280              """) 
19281      ip4 = convert_to_int(p4) 
19282      ip5 = convert_to_int(p5) 
19283      ip6 = convert_to_int(p6) 
19284      keep_elem_refs(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, pImage, 
19285                     ip4, ip5, ip6) 
19286      retval = _fl_j2pass_quantize_rgb(p1, p2, p3, ip4, ip5, ip6, p7, p8, p9, \ 
19287                                       p10, p11, pImage) 
19288      return retval 
19289   
19290   
19291 -def fl_make_submatrix(in_, rows, cols, r1, c1, rs, cs, esize): 
19292      """ fl_make_submatrix(in_, rows, cols, r1, c1, rs, cs, esize) -> ? 
19293      """ 
19294   
19295      _fl_make_submatrix = cfuncproto( 
19296              load_so_libflimage(), "fl_make_submatrix", 
19297              cty.c_void_p, [cty.c_void_p, cty.c_int, cty.c_int, cty.c_int, 
19298              cty.c_int, cty.c_int, cty.c_int, cty.c_uint], 
19299              """void * fl_make_submatrix(void * p1, int p2, int p3, int p4, 
19300                 int p5, int p6, int p7, unsigned int p8) 
19301              """) 
19302      irows = convert_to_int(rows) 
19303      icols = convert_to_int(cols) 
19304      ir1 = convert_to_int(r1) 
19305      ic1 = convert_to_int(c1) 
19306      irs = convert_to_int(rs) 
19307      ics = convert_to_int(cs) 
19308      uiesize = convert_to_uint(esize) 
19309      keep_elem_refs(in_, rows, cols, r1, c1, rs, cs, esize, irows, icols, \ 
19310                 ir1, ic1, irs, ics, uiesize) 
19311      retval = _fl_make_submatrix(in_, irows, icols, ir1, ic1, irs, ics, \ 
19312                                  uiesize) 
19313      return retval 
19314   
19315   
19316 -def fl_pack_bits(p1, p2, p3): 
19317      """ fl_pack_bits(p1, p2, p3) 
19318      """ 
19319   
19320      _fl_pack_bits = cfuncproto( 
19321              load_so_libflimage(), "fl_pack_bits", 
19322              None, [cty.POINTER(cty.c_ubyte), cty.POINTER(cty.c_ushort), 
19323              cty.c_int], 
19324              """void fl_pack_bits(unsigned char * p1, short unsigned int * p2, 
19325                 int p3) 
19326              """) 
19327      ip3 = convert_to_int(p3) 
19328      keep_elem_refs(p1, p2, p3, ip3) 
19329      _fl_pack_bits(p1, p2, ip3) 
19330   
19331   
19332 -def fl_unpack_bits(p1, p2, p3): 
19333      """ fl_unpack_bits(p1, p2, p3) 
19334      """ 
19335   
19336      _fl_unpack_bits = cfuncproto( 
19337              load_so_libflimage(), "fl_unpack_bits", 
19338              None, [cty.POINTER(cty.c_ushort), cty.POINTER(cty.c_ubyte), 
19339              cty.c_int], 
19340              """void fl_unpack_bits(short unsigned int * p1, 
19341                 unsigned char * p2, int p3) 
19342              """) 
19343      ip3 = convert_to_int(p3) 
19344      keep_elem_refs(p1, p2, p3, ip3) 
19345      _fl_unpack_bits(p1, p2, ip3) 
19346   
19347   
19348 -def fl_value_to_bits(p1): 
19349      """ fl_value_to_bits(p1) -> num. 
19350      """ 
19351   
19352      _fl_value_to_bits = cfuncproto( 
19353              load_so_libflimage(), "fl_value_to_bits", 
19354              cty.c_uint, [cty.c_uint], 
19355              """)unsigned int fl_value_to_bits(unsigned int p1) 
19356              """) 
19357      uip1 = convert_to_uint(p1) 
19358      keep_elem_refs(p1, uip1) 
19359      retval = _fl_value_to_bits(uip1) 
19360      return retval 
19361   
19362   
19363 -def flimage_add_comments(pImage, p2, p3): 
19364      """ flimage_add_comments(pImage, p2, p3) 
19365      """ 
19366   
19367      _flimage_add_comments = cfuncproto( 
19368              load_so_libflimage(), "flimage_add_comments", 
19369              None, [cty.POINTER(FL_IMAGE), STRING, cty.c_int], 
19370              """void flimage_add_comments(FL_IMAGE * p1, const char * p2, 
19371                 int p3) 
19372              """) 
19373      sp2 = convert_to_string(p2) 
19374      ip3 = convert_to_int(p3) 
19375      keep_elem_refs(pImage, p2, p3, sp2, ip3) 
19376      _flimage_add_comments(pImage, sp2, ip3) 
19377   
19378   
19379 -def flimage_color_to_pixel(pImage, p2, p3, p4, p5): 
19380      """ flimage_color_to_pixel(pImage, p2, p3, p4, p5) -> num. 
19381      """ 
19382   
19383      _flimage_color_to_pixel = cfuncproto( 
19384              load_so_libflimage(), "flimage_color_to_pixel", 
19385              cty.c_ulong, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, 
19386              cty.c_int, cty.POINTER(cty.c_int)], 
19387              """)long unsigned int flimage_color_to_pixel(FL_IMAGE * p1, 
19388                 int p2, int p3, int p4, int * p5) 
19389              """) 
19390      ip2 = convert_to_int(p2) 
19391      ip3 = convert_to_int(p3) 
19392      ip4 = convert_to_int(p4) 
19393      keep_elem_refs(pImage, p2, p3, p4, p5, ip2, ip3, ip4) 
19394      retval = _flimage_color_to_pixel(pImage, ip2, ip3, ip4, p5) 
19395      return retval 
19396   
19397   
19398 -def flimage_combine(pImage1, pImage2, p3): 
19399      """ flimage_combine(pImage1, pImage2, p3) -> pImage 
19400      """ 
19401   
19402      _flimage_combine = cfuncproto( 
19403              load_so_libflimage(), "flimage_combine", 
19404              cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE), 
19405              cty.POINTER(FL_IMAGE), cty.c_double], 
19406              """FL_IMAGE * flimage_combine(FL_IMAGE * p1, FL_IMAGE * p2, 
19407                 double p3) 
19408              """) 
19409      fp3 = convert_to_double(p3) 
19410      keep_elem_refs(pImage1, pImage2, p3, fp3) 
19411      retval = _flimage_combine(pImage1, pImage2, fp3) 
19412      return retval 
19413   
19414   
19415 -def flimage_display_markers(pImage): 
19416      """ flimage_display_markers(pImage) 
19417      """ 
19418   
19419      _flimage_display_markers = cfuncproto( 
19420              load_so_libflimage(), "flimage_display_markers", 
19421              None, [cty.POINTER(FL_IMAGE)], 
19422              """void flimage_display_markers(FL_IMAGE * p1) 
19423              """) 
19424      keep_elem_refs(pImage) 
19425      _flimage_display_markers(pImage) 
19426   
19427   
19428 -def flimage_dup_(pImage, p2): 
19429      """ flimage_dup_(pImage, p2) -> pImage 
19430      """ 
19431   
19432      _flimage_dup_ = cfuncproto( 
19433              load_so_libflimage(), "flimage_dup_", 
19434              cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE), cty.c_int], 
19435              """FL_IMAGE * flimage_dup_(FL_IMAGE * p1, int p2) 
19436              """) 
19437      ip2 = convert_to_int(p2) 
19438      keep_elem_refs(pImage, p2, ip2) 
19439      retval = _flimage_dup_(pImage, ip2) 
19440      return retval 
19441   
19442   
19443 -def flimage_enable_bmp(): 
19444      """ flimage_enable_bmp() 
19445      """ 
19446   
19447      _flimage_enable_bmp = cfuncproto( 
19448              load_so_libflimage(), "flimage_enable_bmp", 
19449              None, [], 
19450              """void flimage_enable_bmp() 
19451              """) 
19452      _flimage_enable_bmp() 
19453   
19454   
19455 -def flimage_enable_fits(): 
19456      """ flimage_enable_fits() 
19457      """ 
19458   
19459      _flimage_enable_fits = cfuncproto( 
19460              load_so_libflimage(), "flimage_enable_fits", 
19461              None, [], 
19462              """void flimage_enable_fits() 
19463              """) 
19464      _flimage_enable_fits() 
19465   
19466   
19467 -def flimage_enable_genesis(): 
19468      """ flimage_enable_genesis() 
19469      """ 
19470   
19471      _flimage_enable_genesis = cfuncproto( 
19472              load_so_libflimage(), "flimage_enable_genesis", 
19473              None, [], 
19474              """void flimage_enable_genesis() 
19475              """) 
19476      _flimage_enable_genesis() 
19477   
19478   
19479 -def flimage_enable_gif(): 
19480      """ flimage_enable_gif() 
19481      """ 
19482   
19483      _flimage_enable_gif = cfuncproto( 
19484              load_so_libflimage(), "flimage_enable_gif", 
19485              None, [], 
19486              """void flimage_enable_gif() 
19487              """) 
19488      _flimage_enable_gif() 
19489   
19490   
19491 -def flimage_enable_gzip(): 
19492      """ flimage_enable_gzip() 
19493      """ 
19494   
19495      _flimage_enable_gzip = cfuncproto( 
19496              load_so_libflimage(), "flimage_enable_gzip", 
19497              None, [], 
19498              """void flimage_enable_gzip() 
19499              """) 
19500      _flimage_enable_gzip() 
19501   
19502   
19503 -def flimage_enable_jpeg(): 
19504      """ flimage_enable_jpeg() 
19505      """ 
19506   
19507      _flimage_enable_jpeg = cfuncproto( 
19508              load_so_libflimage(), "flimage_enable_jpeg", 
19509              None, [], 
19510              """void flimage_enable_jpeg() 
19511              """) 
19512      _flimage_enable_jpeg() 
19513   
19514   
19515 -def flimage_enable_png(): 
19516      """ flimage_enable_png() 
19517      """ 
19518   
19519      _flimage_enable_png = cfuncproto( 
19520              load_so_libflimage(), "flimage_enable_png", 
19521              None, [], 
19522              """void flimage_enable_png() 
19523              """) 
19524      _flimage_enable_png() 
19525   
19526   
19527 -def flimage_enable_ps(): 
19528      """ flimage_enable_ps() 
19529      """ 
19530   
19531      _flimage_enable_ps = cfuncproto( 
19532              load_so_libflimage(), "flimage_enable_ps", 
19533              None, [], 
19534              """void flimage_enable_ps() 
19535              """) 
19536      _flimage_enable_ps() 
19537   
19538   
19539 -def flimage_enable_sgi(): 
19540      """ flimage_enable_sgi() 
19541      """ 
19542   
19543      _flimage_enable_sgi = cfuncproto( 
19544              load_so_libflimage(), "flimage_enable_sgi", 
19545              None, [], 
19546              """void flimage_enable_sgi() 
19547              """) 
19548      _flimage_enable_sgi() 
19549   
19550   
19551 -def flimage_enable_tiff(): 
19552      """ flimage_enable_tiff() 
19553      """ 
19554   
19555      _flimage_enable_tiff = cfuncproto( 
19556              load_so_libflimage(), "flimage_enable_tiff", 
19557              None, [], 
19558              """void flimage_enable_tiff() 
19559              """) 
19560      _flimage_enable_tiff() 
19561   
19562   
19563 -def flimage_enable_xbm(): 
19564      """ flimage_enable_xbm() 
19565      """ 
19566   
19567      _flimage_enable_xbm = cfuncproto( 
19568              load_so_libflimage(), "flimage_enable_xbm", 
19569              None, [], 
19570              """void flimage_enable_xbm() 
19571              """) 
19572      _flimage_enable_xbm() 
19573   
19574   
19575 -def flimage_enable_xpm(): 
19576      """ flimage_enable_xpm() 
19577      """ 
19578   
19579      _flimage_enable_xpm = cfuncproto( 
19580              load_so_libflimage(), "flimage_enable_xpm", 
19581              None, [], 
19582              """void flimage_enable_xpm() 
19583              """) 
19584      _flimage_enable_xpm() 
19585   
19586   
19587 -def flimage_enable_xwd(): 
19588      """ flimage_enable_xwd() 
19589      """ 
19590   
19591      _flimage_enable_xwd = cfuncproto( 
19592              load_so_libflimage(), "flimage_enable_xwd", 
19593              None, [], 
19594              """void flimage_enable_xwd() 
19595              """) 
19596      _flimage_enable_xwd() 
19597   
19598   
19599 -def flimage_free_ci(pImage): 
19600      """ flimage_free_ci(pImage) 
19601      """ 
19602   
19603      _flimage_free_ci = cfuncproto( 
19604              load_so_libflimage(), "flimage_free_ci", 
19605              None, [cty.POINTER(FL_IMAGE)], 
19606              """void flimage_free_ci(FL_IMAGE * p1) 
19607              """) 
19608      keep_elem_refs(pImage) 
19609      _flimage_free_ci(pImage) 
19610   
19611   
19612 -def flimage_free_gray(pImage): 
19613      """ flimage_free_gray(pImage) 
19614      """ 
19615   
19616      _flimage_free_gray = cfuncproto( 
19617              load_so_libflimage(), "flimage_free_gray", 
19618              None, [cty.POINTER(FL_IMAGE)], 
19619              """void flimage_free_gray(FL_IMAGE * p1) 
19620              """) 
19621      keep_elem_refs(pImage) 
19622      _flimage_free_gray(pImage) 
19623   
19624   
19625 -def flimage_free_linearlut(pImage): 
19626      """ flimage_free_linearlut(pImage) 
19627      """ 
19628   
19629      _flimage_free_linearlut = cfuncproto( 
19630              load_so_libflimage(), "flimage_free_linearlut", 
19631              None, [cty.POINTER(FL_IMAGE)], 
19632              """void flimage_free_linearlut(FL_IMAGE * p1) 
19633              """) 
19634      keep_elem_refs(pImage) 
19635      _flimage_free_linearlut(pImage) 
19636   
19637   
19638 -def flimage_free_rgb(pImage): 
19639      """ flimage_free_rgb(pImage) 
19640      """ 
19641   
19642      _flimage_free_rgb = cfuncproto( 
19643              load_so_libflimage(), "flimage_free_rgb", 
19644              None, [cty.POINTER(FL_IMAGE)], 
19645              """void flimage_free_rgb(FL_IMAGE * p1) 
19646              """) 
19647      keep_elem_refs(pImage) 
19648      _flimage_free_rgb(pImage) 
19649   
19650   
19651 -def flimage_freemem(pImage): 
19652      """ flimage_freemem(pImage) 
19653      """ 
19654   
19655      _flimage_freemem = cfuncproto( 
19656              load_so_libflimage(), "flimage_freemem", 
19657              None, [cty.POINTER(FL_IMAGE)], 
19658              """void flimage_freemem(FL_IMAGE * p1) 
19659              """) 
19660      keep_elem_refs(pImage) 
19661      _flimage_freemem(pImage) 
19662   
19663   
19664 -def flimage_get_closest_color_from_map(pImage, p2): 
19665      """ flimage_get_closest_color_from_map(pImage, p2) -> num. 
19666      """ 
19667   
19668      _flimage_get_closest_color_from_map = cfuncproto( 
19669              load_so_libflimage(), "flimage_get_closest_color_from_map", 
19670              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint], 
19671              """int flimage_get_closest_color_from_map(FL_IMAGE * p1, 
19672                 unsigned int p2) 
19673              """) 
19674      uip2 = convert_to_uint(p2) 
19675      keep_elem_refs(pImage, p2, uip2) 
19676      retval = _flimage_get_closest_color_from_map(pImage, uip2) 
19677      return retval 
19678   
19679   
19680 -def flimage_get_linearlut(pImage): 
19681      """ flimage_get_linearlut(pImage) -> num. 
19682      """ 
19683   
19684      _flimage_get_linearlut = cfuncproto( 
19685              load_so_libflimage(), "flimage_get_linearlut", 
19686              cty.c_int, [cty.POINTER(FL_IMAGE)], 
19687              """int flimage_get_linearlut(FL_IMAGE * p1) 
19688              """) 
19689      keep_elem_refs(pImage) 
19690      retval = _flimage_get_linearlut(pImage) 
19691      return retval 
19692   
19693   
19694 -def flimage_invalidate_pixels(pImage): 
19695      """ flimage_invalidate_pixels(pImage) 
19696      """ 
19697   
19698      _flimage_invalidate_pixels = cfuncproto( 
19699              load_so_libflimage(), "flimage_invalidate_pixels", 
19700              None, [cty.POINTER(FL_IMAGE)], 
19701              """void flimage_invalidate_pixels(FL_IMAGE * p1) 
19702              """) 
19703      keep_elem_refs(pImage) 
19704      _flimage_invalidate_pixels(pImage) 
19705   
19706   
19707 -def flimage_open(filename): 
19708      """ flimage_open(filename) -> pImage 
19709      """ 
19710   
19711      _flimage_open = cfuncproto( 
19712              load_so_libflimage(), "flimage_open", 
19713              cty.POINTER(FL_IMAGE), [STRING], 
19714              """FL_IMAGE * flimage_open(const char * p1) 
19715              """) 
19716      sfilename = convert_to_string(filename) 
19717      keep_elem_refs(filename, sfilename) 
19718      retval = _flimage_open(sfilename) 
19719      return retval 
19720   
19721   
19722 -def flimage_read_annotation(pImage): 
19723      """ flimage_read_annotation(pImage) -> num. 
19724      """ 
19725   
19726      _flimage_read_annotation = cfuncproto( 
19727              load_so_libflimage(), "flimage_read_annotation", 
19728              cty.c_int, [cty.POINTER(FL_IMAGE)], 
19729              """int flimage_read_annotation(FL_IMAGE * p1) 
19730              """) 
19731      keep_elem_refs(pImage) 
19732      retval = _flimage_read_annotation(pImage) 
19733      return retval 
19734   
19735   
19736 -def flimage_replace_image(pImage, w, h, r, g, b): 
19737      """ flimage_replace_image(pImage, w, h, r, g, b) 
19738      """ 
19739   
19740      _flimage_replace_image = cfuncproto( 
19741              load_so_libflimage(), "flimage_replace_image", 
19742              None, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, cty.c_void_p, 
19743              cty.c_void_p, cty.c_void_p], 
19744              """void flimage_replace_image(FL_IMAGE * p1, int p2, int p3, 
19745                 void * p4, void * p5, void * p6) 
19746              """) 
19747      iw = convert_to_int(w) 
19748      ih = convert_to_int(h) 
19749      pr = cty.cast(r, cty.c_void_p) 
19750      pg = cty.cast(g, cty.c_void_p) 
19751      pb = cty.cast(b, cty.c_void_p) 
19752      keep_elem_refs(pImage, w, h, r, g, b, iw, ih, pr, pg, pb) 
19753      _flimage_replace_image(pImage, iw, ih, pr, pg, pb) 
19754   
19755   
19756 -def flimage_swapbuffer(pImage): 
19757      """ flimage_swapbuffer(pImage) -> num. 
19758      """ 
19759   
19760      _flimage_swapbuffer = cfuncproto( 
19761              load_so_libflimage(), "flimage_swapbuffer", 
19762              cty.c_int, [cty.POINTER(FL_IMAGE)], 
19763              """int flimage_swapbuffer(FL_IMAGE * p1) 
19764              """) 
19765      keep_elem_refs(pImage) 
19766      retval = _flimage_swapbuffer(pImage) 
19767      return retval 
19768   
19769   
19770 -def flimage_to_ximage(pImage, win, pXWindowAttributes): 
19771      """ flimage_to_ximage(pImage, win, pXWindowAttributes) -> num. 
19772      """ 
19773   
19774      _flimage_to_ximage = cfuncproto( 
19775              load_so_libflimage(), "flimage_to_ximage", 
19776              cty.c_int, [cty.POINTER(FL_IMAGE), FL_WINDOW, 
19777              cty.POINTER(XWindowAttributes)], 
19778              """int flimage_to_ximage(FL_IMAGE * p1, FL_WINDOW p2, 
19779                 XWindowAttributes * p3) 
19780              """) 
19781      ulwin = convert_to_Window(win) 
19782      keep_elem_refs(pImage, win, pXWindowAttributes, ulwin) 
19783      retval = _flimage_to_ximage(pImage, ulwin, pXWindowAttributes) 
19784      return retval 
19785   
19786   
19787 -def flimage_write_annotation(pImage): 
19788      """ flimage_write_annotation(pImage) -> num. 
19789      """ 
19790   
19791      _flimage_write_annotation = cfuncproto( 
19792              load_so_libflimage(), "flimage_write_annotation", 
19793              cty.c_int, [cty.POINTER(FL_IMAGE)], 
19794              """int flimage_write_annotation(FL_IMAGE * p1) 
19795              """) 
19796      keep_elem_refs(pImage) 
19797      retval = _flimage_write_annotation(pImage) 
19798      return retval 
19799   
19800   
19801 -def flps_apply_gamma(p1): 
19802      """ flps_apply_gamma(p1) 
19803      """ 
19804   
19805      _flps_apply_gamma = cfuncproto( 
19806              load_so_libflimage(), "flps_apply_gamma", 
19807              None, [cty.c_float], 
19808              """void flps_apply_gamma(float p1) 
19809              """) 
19810      fp1 = convert_to_float(p1) 
19811      keep_elem_refs(p1, fp1) 
19812      _flps_apply_gamma(fp1) 
19813   
19814   
19815 -def flps_arc(fill, x, y, r, t1, t2, colr): 
19816      """ flps_arc(p1, p2, p3, p4, p5, p6, p7) 
19817      """ 
19818   
19819      _flps_arc = cfuncproto( 
19820              load_so_libflimage(), "flps_arc", 
19821              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
19822              cty.c_int, cty.c_long], 
19823              """void flps_arc(int p1, int p2, int p3, int p4, int p5, int p6, 
19824                 long int p7) 
19825              """) 
19826      ifill = convert_to_int(fill) 
19827      ix = convert_to_int(x) 
19828      iy = convert_to_int(y) 
19829      ir = convert_to_int(r) 
19830      it1 = convert_to_int(t1) 
19831      it2 = convert_to_int(t2) 
19832      lcolr = convert_to_long(colr) 
19833      keep_elem_refs(fill, x, y, r, t1, t2, colr, ifill, ix, iy, ir, it1, \ 
19834                     it2, lcolr) 
19835      _flps_arc(ifill, ix, iy, ir, it1, it2, lcolr) 
19836   
19837   
19838 -def flps_circ(fill, x, y, r, colr): 
19839      """ flps_circ(fill, x, y, r, colr) 
19840      """ 
19841   
19842      _flps_circ = cfuncproto( 
19843              load_so_libflimage(), "flps_circ", 
19844              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_long], 
19845              """void flps_circ(int p1, int p2, int p3, int p4, long int p5) 
19846              """) 
19847      ifill = convert_to_int(fill) 
19848      ix = convert_to_int(x) 
19849      iy = convert_to_int(y) 
19850      ir = convert_to_int(r) 
19851      lcolr = convert_to_long(colr) 
19852      keep_elem_refs(fill, x, y, r, colr, ifill, ix, iy, ir, lcolr) 
19853      _flps_circ(fill, x, y, r, colr, ifill, ix, iy, ir, lcolr) 
19854   
19855   
19856 -def flps_color(colr): 
19857      """ flps_color(colr) 
19858      """ 
19859   
19860      _flps_color = cfuncproto( 
19861              load_so_libflimage(), "flps_color", 
19862              None, [cty.c_long], 
19863              """void flps_color(long int p1) 
19864              """) 
19865      lcolr = convert_to_long(colr) 
19866      keep_elem_refs(colr, lcolr) 
19867      _flps_color(lcolr) 
19868   
19869   
19870 -def flps_draw_box(style, x, y, w, h, colr, bwIn): 
19871      """ flps_draw_box(style, x, y, w, h, colr, bwIn) 
19872      """ 
19873   
19874      _flps_draw_box = cfuncproto( 
19875              load_so_libflimage(), "flps_draw_box", 
19876              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
19877              cty.c_long, cty.c_int], 
19878              """void flps_draw_box(int p1, int p2, int p3, int p4, int p5, 
19879                 long int p6, int p7) 
19880              """) 
19881      istyle = convert_to_int(style) 
19882      ix = convert_to_int(x) 
19883      iy = convert_to_int(y) 
19884      iw = convert_to_int(w) 
19885      ih = convert_to_int(h) 
19886      lcolr = convert_to_long(colr) 
19887      ibwIn = convert_to_int(bwIn) 
19888      keep_elem_refs(style, x, y, w, h, colr, bwIn, istyle, ix, iy, iw, ih, \ 
19889                     lcolr, ibwIn) 
19890      _flps_draw_box(istyle, ix, iy, iw, ih, lcolr, ibwIn) 
19891   
19892   
19893 -def flps_draw_checkbox(boxtype, x, y, w, h, colr, bw): 
19894      """ flps_draw_checkbox(boxtype, x, y, w, h, colr, bw) 
19895      """ 
19896   
19897      _flps_draw_checkbox = cfuncproto( 
19898              load_so_libflimage(), "flps_draw_checkbox", 
19899              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
19900              cty.c_long, cty.c_int], 
19901              """void flps_draw_checkbox(int p1, int p2, int p3, int p4, 
19902                 int p5, long int p6, int p7) 
19903              """) 
19904      iboxtype = convert_to_int(boxtype) 
19905      ix = convert_to_int(x) 
19906      iy = convert_to_int(y) 
19907      iw = convert_to_int(w) 
19908      ih = convert_to_int(h) 
19909      lcolr = convert_to_long(colr) 
19910      ibw = convert_to_int(bw) 
19911      keep_elem_refs(boxtype, x, y, w, h, colr, bw, iboxtype, ix, iy, iw, ih, \ 
19912                     lcolr, ibw) 
19913      _flps_draw_checkbox(iboxtype, ix, iy, iw, ih, lcolr, ibw) 
19914   
19915   
19916 -def flps_draw_frame(style, x, y, w, h, colr, bw): 
19917      """ flps_draw_frame(style, x, y, w, h, colr, bw) 
19918      """ 
19919   
19920      _flps_draw_frame = cfuncproto( 
19921              load_so_libflimage(), "flps_draw_frame", 
19922              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
19923              cty.c_long, cty.c_int], 
19924              """void flps_draw_frame(int p1, int p2, int p3, int p4, int p5, 
19925                 long int p6, int p7) 
19926              """) 
19927      istyle = convert_to_int(style) 
19928      ix = convert_to_int(x) 
19929      iy = convert_to_int(y) 
19930      iw = convert_to_int(w) 
19931      ih = convert_to_int(h) 
19932      lcolr = convert_to_long(colr) 
19933      ibw = convert_to_int(bw) 
19934      keep_elem_refs(style, x, y, w, h, colr, bw, istyle, ix, iy, iw, ih, \ 
19935                     lcolr, ibw) 
19936      _flps_draw_frame(istyle, ix, iy, iw, ih, lcolr, ibw) 
19937   
19938   
19939 -def flps_draw_symbol(label, x, y, w, h, colr): 
19940      """ flps_draw_symbol(label, x, y, w, h, colr) -> num. 
19941      """ 
19942   
19943      _flps_draw_symbol = cfuncproto( 
19944              load_so_libflimage(), "flps_draw_symbol", 
19945              cty.c_int, [STRING, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
19946              cty.c_long], 
19947              """int flps_draw_symbol(const char * p1, int p2, int p3, int p4, 
19948                 int p5, long int p6) 
19949              """) 
19950      slabel = convert_to_string(label) 
19951      ix = convert_to_int(x) 
19952      iy = convert_to_int(y) 
19953      iw = convert_to_int(w) 
19954      ih = convert_to_int(h) 
19955      lcolr = convert_to_long(colr) 
19956      keep_elem_refs(label, x, y, w, h, colr, slabel, ix, iy, iw, ih, lcolr) 
19957      retval = _flps_draw_symbol(slabel, ix, iy, iw, ih, lcolr) 
19958      return retval 
19959   
19960   
19961 -def flps_draw_tbox(style, x, y, w, h, colr, bw): 
19962      """ flps_draw_tbox(style, x, y, w, h, colr, bw) 
19963      """ 
19964   
19965      _flps_draw_tbox = cfuncproto( 
19966              load_so_libflimage(), "flps_draw_tbox", 
19967              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
19968              cty.c_long, cty.c_int], 
19969              """void flps_draw_tbox(int p1, int p2, int p3, int p4, int p5, 
19970                 long int p6, int p7) 
19971              """) 
19972      istyle = convert_to_int(style) 
19973      ix = convert_to_int(x) 
19974      iy = convert_to_int(y) 
19975      iw = convert_to_int(w) 
19976      ih = convert_to_int(h) 
19977      lcolr = convert_to_long(colr) 
19978      ibw = convert_to_int(bw) 
19979      keep_elem_refs(style, x, y, w, h, colr, bw, istyle, ix, iy, iw, ih, lcolr, ibw) 
19980      _flps_draw_tbox(istyle, ix, iy, iw, ih, lcolr, ibw) 
19981   
19982   
19983 -def flps_draw_text(align, x, y, w, h, colr, style, size, text): 
19984      """ flps_draw_text(align, x, y, w, h, colr, style, size, text) 
19985      """ 
19986   
19987      _flps_draw_text = cfuncproto( 
19988              load_so_libflimage(), "flps_draw_text", 
19989              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
19990              cty.c_long, cty.c_int, cty.c_int, STRING], 
19991              """void flps_draw_text(int p1, int p2, int p3, int p4, int p5, 
19992                 long int p6, int p7, int p8, const char * p9) 
19993              """) 
19994      ialign = convert_to_int(align) 
19995      ix = convert_to_int(x) 
19996      iy = convert_to_int(y) 
19997      iw = convert_to_int(w) 
19998      ih = convert_to_int(h) 
19999      lcolr = convert_to_long(colr) 
20000      istyle = convert_to_int(style) 
20001      isize = convert_to_int(size) 
20002      stext = convert_to_string(text) 
20003      keep_elem_refs(align, x, y, w, h, colr, style, size, text, ialign, \ 
20004                     ix, iy, iw, ih, lcolr, istyle, isize, stext) 
20005      _flps_draw_text(ialign, ix, iy, iw, ih, lcolr, istyle, isize, stext) 
20006   
20007   
20008 -def flps_draw_text_beside(align, x, y, w, h, colr, style, size, text): 
20009      """ flps_draw_text_beside(align, x, y, w, h, colr, style, size, text) 
20010      """ 
20011   
20012      _flps_draw_text_beside = cfuncproto( 
20013              load_so_libflimage(), "flps_draw_text_beside", 
20014              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20015              cty.c_long, cty.c_int, cty.c_int, STRING], 
20016              """void flps_draw_text_beside(int p1, int p2, int p3, int p4, 
20017                 int p5, long int p6, int p7, int p8, const char * p9) 
20018              """) 
20019      ialign = convert_to_int(align) 
20020      ix = convert_to_int(x) 
20021      iy = convert_to_int(y) 
20022      iw = convert_to_int(w) 
20023      ih = convert_to_int(h) 
20024      lcolr = convert_to_long(colr) 
20025      istyle = convert_to_int(style) 
20026      isize = convert_to_int(size) 
20027      stext = convert_to_string(text) 
20028      keep_elem_refs(align, x, y, w, h, colr, style, size, text, ialign, \ 
20029                     ix, iy, iw, ih, lcolr, istyle, isize, stext) 
20030      _flps_draw_text_beside(ialign, ix, iy, iw, ih, lcolr, istyle, isize, \ 
20031                             stext) 
20032   
20033   
20034 -def flps_emit_header(title, npages, xi, yi, xf, yf): 
20035      """ flps_emit_header(title, npages, xi, yi, xf, yf) 
20036      """ 
20037   
20038      _flps_emit_header = cfuncproto( 
20039              load_so_libflimage(), "flps_emit_header", 
20040              None, [STRING, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20041              cty.c_int], 
20042              """void flps_emit_header(const char * p1, int p2, int p3, 
20043                 int p4, int p5, int p6) 
20044              """) 
20045      stitle = convert_to_string(title) 
20046      inpages = convert_to_int(npages) 
20047      ixi = convert_to_int(xi) 
20048      iyi = convert_to_int(yi) 
20049      ixf = convert_to_int(xf) 
20050      iyf = convert_to_int(yf) 
20051      keep_elem_refs(title, npages, xi, yi, xf, yf, stitle, inpages, ixi, \ 
20052                     iyi, ixf, iyf) 
20053      _flps_emit_header(stitle, inpages, ixi, iyi, ixf, iyf) 
20054   
20055   
20056 -def flps_emit_prolog(): 
20057      """ flps_emit_prolog() 
20058      """ 
20059   
20060      _flps_emit_prolog = cfuncproto( 
20061              load_so_libflimage(), "flps_emit_prolog", 
20062              None, [], 
20063              """void flps_emit_prolog() 
20064              """) 
20065      _flps_emit_prolog() 
20066   
20067   
20068 -def flps_get_gray255(colr): 
20069      """ flps_get_gray255(colr) -> num. 
20070      """ 
20071   
20072      _flps_get_gray255 = cfuncproto( 
20073              load_so_libflimage(), "flps_get_gray255", 
20074              cty.c_int, [cty.c_long], 
20075              """int flps_get_gray255(long int p1) 
20076              """) 
20077      lcolr = convert_to_long(colr) 
20078      keep_elem_refs(colr, lcolr) 
20079      retval = _flps_get_gray255(lcolr) 
20080      return retval 
20081   
20082   
20083 -def flps_get_linestyle(): 
20084      """ flps_get_linestyle() -> num. 
20085      """ 
20086   
20087      _flps_get_linestyle = cfuncproto( 
20088              load_so_libflimage(), "flps_get_linestyle", 
20089              cty.c_int, [], 
20090              """int flps_get_linestyle() 
20091              """) 
20092      retval = _flps_get_linestyle() 
20093      return retval 
20094   
20095   
20096 -def flps_get_linewidth(): 
20097      """ flps_get_linewidth() -> width num. 
20098      """ 
20099   
20100      _flps_get_linewidth = cfuncproto( 
20101              load_so_libflimage(), "flps_get_linewidth", 
20102              cty.c_int, [], 
20103              """int flps_get_linewidth() 
20104              """) 
20105      retval = _flps_get_linewidth() 
20106      return retval 
20107   
20108   
20109 -def flps_get_namedcolor(colrname): 
20110      """ flps_get_namedcolor(colrname) -> num. 
20111      """ 
20112   
20113      _flps_get_namedcolor = cfuncproto( 
20114              load_so_libflimage(), "flps_get_namedcolor", 
20115              cty.c_int, [STRING], 
20116              """int flps_get_namedcolor(const char * p1) 
20117              """) 
20118      scolrname = convert_to_string(colrname) 
20119      keep_elem_refs(colrname, scolrname) 
20120      retval = _flps_get_namedcolor(scolrname) 
20121      return retval 
20122   
20123   
20124 -def flps_invalidate_color_cache(): 
20125      """ flps_invalidate_color_cache() 
20126      """ 
20127   
20128      _flps_invalidate_color_cache = cfuncproto( 
20129              load_so_libflimage(), "flps_invalidate_color_cache", 
20130              None, [], 
20131              """void flps_invalidate_color_cache() 
20132              """) 
20133      _flps_invalidate_color_cache() 
20134   
20135   
20136 -def flps_invalidate_font_cache(): 
20137      """ flps_invalidate_font_cache() 
20138      """ 
20139   
20140      _flps_invalidate_font_cache = cfuncproto( 
20141              load_so_libflimage(), "flps_invalidate_font_cache", 
20142              None, [], 
20143              """void flps_invalidate_font_cache() 
20144              """) 
20145      _flps_invalidate_font_cache() 
20146   
20147   
20148 -def flps_invalidate_linewidth_cache(): 
20149      """ flps_invalidate_linewidth_cache() 
20150      """ 
20151   
20152      _flps_invalidate_linewidth_cache = cfuncproto( 
20153              load_so_libflimage(), "flps_invalidate_linewidth_cache", 
20154              None, [], 
20155              """void flps_invalidate_linewidth_cache() 
20156              """) 
20157      _flps_invalidate_linewidth_cache() 
20158   
20159   
20160 -def flps_invalidate_symbol_cache(): 
20161      """ flps_invalidate_symbol_cache() 
20162      """ 
20163   
20164      _flps_invalidate_symbol_cache = cfuncproto( 
20165              load_so_libflimage(), "flps_invalidate_symbol_cache", 
20166              None, [], 
20167              """void flps_invalidate_symbol_cache() 
20168              """) 
20169      _flps_invalidate_symbol_cache() 
20170   
20171   
20172 -def flps_line(xi, yi, xf, yf, colr): 
20173      """ flps_line(xi, yi, xf, yf, colr) 
20174      """ 
20175   
20176      _flps_line = cfuncproto( 
20177              load_so_libflimage(), "flps_line", 
20178              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_long], 
20179              """void flps_line(int p1, int p2, int p3, int p4, long int p5) 
20180              """) 
20181      ixi = convert_to_int(xi) 
20182      iyi = convert_to_int(yi) 
20183      ixf = convert_to_int(xf) 
20184      iyf = convert_to_int(yf) 
20185      lcolr = convert_to_long(colr) 
20186      keep_elem_refs(xi, yi, xf, yf, colr, ixi, iyi, ixf, iyf, lcolr) 
20187      _flps_line(ixi, iyi, ixf, iyf, lcolr) 
20188   
20189   
20190 -def flps_lines(pPoint, num, colr): 
20191      """ flps_lines(pPoint, num, colr) 
20192      """ 
20193   
20194      _flps_lines = cfuncproto( 
20195              load_so_libflimage(), "flps_lines", 
20196              None, [cty.POINTER(FL_POINT), cty.c_int, cty.c_long], 
20197              """void flps_lines(FL_POINT * p1, int p2, long int p3) 
20198              """) 
20199      inum = convert_to_int(num) 
20200      lcolr = convert_to_long(colr) 
20201      keep_elem_refs(pPoint, num, colr, inum, lcolr) 
20202      _flps_lines(pPoint, inum, lcolr) 
20203   
20204   
20205 -def flps_linestyle(linestyle): 
20206      """ flps_linestyle(linestyle) 
20207      """ 
20208   
20209      _flps_linestyle = cfuncproto( 
20210              load_so_libflimage(), "flps_linestyle", 
20211              None, [cty.c_int], 
20212              """void flps_linestyle(int p1) 
20213              """) 
20214      check_admitted_listvalues(linestyle, LINE_list) 
20215      ilinestyle = convert_to_int(linestyle) 
20216      keep_elem_refs(linestyle, ilinestyle) 
20217      _flps_linestyle(ilinestyle) 
20218   
20219   
20220 -def flps_linewidth(linewidth): 
20221      """ flps_linewidth(linewidth) 
20222      """ 
20223   
20224      _flps_linewidth = cfuncproto( 
20225              load_so_libflimage(), "flps_linewidth", 
20226              None, [cty.c_int], 
20227              """void flps_linewidth(int p1) 
20228              """) 
20229      ilinewidth = convert_to_int(linewidth) 
20230      keep_elem_refs(linewidth, ilinewidth) 
20231      _flps_linewidth(ilinewidth) 
20232   
20233   
20234 -def flps_log(text): 
20235      """ flps_log(text) 
20236      """ 
20237   
20238      _flps_log = cfuncproto( 
20239              load_so_libflimage(), "flps_log", 
20240              None, [STRING], 
20241              """void flps_log(const char * p1) 
20242              """) 
20243      stext = convert_to_string(text) 
20244      keep_elem_refs(text, stext) 
20245      _flps_log(stext) 
20246   
20247   
20248 -def flps_output(fmt): 
20249      """ flps_output(fmt) 
20250      """ 
20251   
20252      _flps_output = cfuncproto( 
20253              load_so_libflimage(), "flps_output", 
20254              None, [STRING], 
20255              """void flps_output(const char * p1) 
20256              """) 
20257      sfmt = convert_to_string(fmt) 
20258      keep_elem_refs(fmt, sfmt) 
20259      _flps_output(sfmt) 
20260   
20261   
20262 -def flps_oval(fill, x, y, w, h, colr): 
20263      """ flps_oval(fill, x, y, w, h, colr) 
20264      """ 
20265   
20266      _flps_oval = cfuncproto( 
20267              load_so_libflimage(), "flps_oval", 
20268              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20269              cty.c_long], 
20270              """void flps_oval(int p1, int p2, int p3, int p4, int p5, 
20271                 long int p6) 
20272              """) 
20273      ifill = convert_to_int(fill) 
20274      ix = convert_to_int(x) 
20275      iy = convert_to_int(y) 
20276      iw = convert_to_int(w) 
20277      ih = convert_to_int(h) 
20278      lcolr = convert_to_long(colr) 
20279      keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, lcolr) 
20280      _flps_oval(ifill, ix, iy, iw, ih, lcolr) 
20281   
20282   
20283 -def flps_pieslice(fill, x, y, w, h, t1, t2, colr): 
20284      """ flps_pieslice(fill, x, y, w, h, t1, t2, colr) 
20285      """ 
20286   
20287      _flps_pieslice = cfuncproto( 
20288              load_so_libflimage(), "flps_pieslice", 
20289              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20290              cty.c_int, cty.c_int, cty.c_long], 
20291              """void flps_pieslice(int p1, int p2, int p3, int p4, int p5, 
20292                 int p6, int p7, long int p8) 
20293              """) 
20294      ifill = convert_to_int(fill) 
20295      ix = convert_to_int(x) 
20296      iy = convert_to_int(y) 
20297      iw = convert_to_int(w) 
20298      ih = convert_to_int(h) 
20299      it1 = convert_to_int(t1) 
20300      it2 = convert_to_int(t2) 
20301      lcolr = convert_to_long(colr) 
20302      keep_elem_refs(fill, x, y, w, h, t1, t2, colr, ifill, ix, iy, iw, \ 
20303                     ih, it1, it2, lcolr) 
20304      _flps_pieslice(ifill, ix, iy, iw, ih, it1, it2, lcolr) 
20305   
20306   
20307 -def flps_poly(fill, pPoint, num, colr): 
20308      """ flps_poly(fill, pPoint, num, colr) 
20309      """ 
20310   
20311      _flps_poly = cfuncproto( 
20312              load_so_libflimage(), "flps_poly", 
20313              None, [cty.c_int, cty.POINTER(FL_POINT), cty.c_int, cty.c_long], 
20314              """void flps_poly(int p1, FL_POINT * p2, int p3, long int p4) 
20315              """) 
20316      ifill = convert_to_int(fill) 
20317      inum = convert_to_int(num) 
20318      lcolr = convert_to_long(colr) 
20319      keep_elem_refs(fill, pPoint, num, colr, ifill, inum, lcolr) 
20320      _flps_poly(ifill, pPoint, inum, lcolr) 
20321   
20322   
20323 -def flps_rectangle(fill, x, y, w, h, colr): 
20324      """ flps_rectangle(fill, x, y, w, h, colr) 
20325      """ 
20326   
20327      _flps_rectangle = cfuncproto( 
20328              load_so_libflimage(), "flps_rectangle", 
20329              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20330              cty.c_long], 
20331              """void flps_rectangle(int p1, int p2, int p3, int p4, int p5, 
20332                 long int p6) 
20333              """) 
20334      ifill = convert_to_int(fill) 
20335      ix = convert_to_int(x) 
20336      iy = convert_to_int(y) 
20337      iw = convert_to_int(w) 
20338      ih = convert_to_int(h) 
20339      lcolr = convert_to_long(colr) 
20340      keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, lcolr) 
20341      _flps_rectangle(ifill, ix, iy, iw, ih, lcolr) 
20342   
20343   
20344 -def flps_reset_cache(): 
20345      """ flps_reset_cache() 
20346      """ 
20347   
20348      _flps_reset_cache = cfuncproto( 
20349              load_so_libflimage(), "flps_reset_cache", 
20350              None, [], 
20351              """void flps_reset_cache() 
20352              """) 
20353      _flps_reset_cache() 
20354   
20355   
20356 -def flps_reset_linewidth(): 
20357      """ flps_reset_linewidth() 
20358      """ 
20359   
20360      _flps_reset_linewidth = cfuncproto( 
20361              load_so_libflimage(), "flps_reset_linewidth", 
20362              None, [], 
20363              """void flps_reset_linewidth() 
20364              """) 
20365      _flps_reset_linewidth() 
20366   
20367   
20368 -def flps_restore_flps(): 
20369      """ flps_restore_flps() 
20370      """ 
20371   
20372      _flps_restore_flps = cfuncproto( 
20373              load_so_libflimage(), "flps_restore_flps", 
20374              None, [], 
20375              """void flps_restore_flps() 
20376              """) 
20377      _flps_restore_flps() 
20378   
20379   
20380 -def flps_rgbcolor(r, g, b): 
20381      """ flps_rgbcolor(r, g, b) 
20382      """ 
20383   
20384      _flps_rgbcolor = cfuncproto( 
20385              load_so_libflimage(), "flps_rgbcolor", 
20386              None, [cty.c_int, cty.c_int, cty.c_int], 
20387              """void flps_rgbcolor(int p1, int p2, int p3) 
20388              """) 
20389      ir = convert_to_int(r) 
20390      ig = convert_to_int(g) 
20391      ib = convert_to_int(b) 
20392      keep_elem_refs(r, g, b, ir, ig, ib) 
20393      _flps_rgbcolor(ir, ig, ib) 
20394   
20395   
20396 -def flps_roundrectangle(fill, x, y, w, h, colr): 
20397      """ flps_roundrectangle(fill, x, y, w, h, colr) 
20398      """ 
20399   
20400      _flps_roundrectangle = cfuncproto( 
20401              load_so_libflimage(), "flps_roundrectangle", 
20402              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20403              cty.c_long], 
20404              """void flps_roundrectangle(int p1, int p2, int p3, int p4, 
20405                 int p5, long int p6) 
20406              """) 
20407      ifill = convert_to_int(fill) 
20408      ix = convert_to_int(x) 
20409      iy = convert_to_int(y) 
20410      iw = convert_to_int(w) 
20411      ih = convert_to_int(h) 
20412      lcolr = convert_to_long(colr) 
20413      keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, lcolr) 
20414      _flps_roundrectangle(ifill, ix, iy, iw, ih, lcolr) 
20415   
20416   
20417 -def flps_set_clipping(x, y, w, h): 
20418      """ flps_set_clipping(x, y, w, h) 
20419      """ 
20420   
20421      _flps_set_clipping = cfuncproto( 
20422              load_so_libflimage(), "flps_set_clipping", 
20423              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int], 
20424              """void flps_set_clipping(int p1, int p2, int p3, int p4) 
20425              """) 
20426      ix = convert_to_int(x) 
20427      iy = convert_to_int(y) 
20428      iw = convert_to_int(w) 
20429      ih = convert_to_int(h) 
20430      keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 
20431      _flps_set_clipping(ix, iy, iw, ih) 
20432   
20433   
20434 -def flps_set_font(style, size): 
20435      """ flps_set_font(style, size) 
20436      """ 
20437   
20438      _flps_set_font = cfuncproto( 
20439              load_so_libflimage(), "flps_set_font", 
20440              None, [cty.c_int, cty.c_int], 
20441              """void flps_set_font(int p1, int p2) 
20442              """) 
20443      check_admitted_listvalues(style, TEXTSTYLE_list) 
20444      istyle = convert_to_int(style) 
20445      isize = convert_to_int(size) 
20446      keep_elem_refs(style, size, istyle, isize) 
20447      _flps_set_font(istyle, isize) 
20448   
20449   
20450 -def flps_unset_clipping(): 
20451      """ flps_unset_clipping() 
20452      """ 
20453   
20454      _flps_unset_clipping = cfuncproto( 
20455              load_so_libflimage(), "flps_unset_clipping", 
20456              None, [], 
20457              """void flps_unset_clipping() 
20458              """) 
20459      _flps_unset_clipping() 
20460